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, unused_mut)]
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 s32_add_fallible(&mut self, arg0: u32, arg1: u32) -> Option<u32>;
25     fn u32_nonnegative(&mut self, arg0: u32) -> Option<u32>;
26     fn offset32(&mut self, arg0: Offset32) -> Option<u32>;
27     fn u32_lteq(&mut self, arg0: u32, arg1: u32) -> Option<Unit>;
28     fn simm32(&mut self, arg0: Imm64) -> Option<u32>;
29     fn uimm8(&mut self, arg0: Imm64) -> Option<u8>;
30     fn u8_and(&mut self, arg0: u8, arg1: u8) -> u8;
31     fn value_reg(&mut self, arg0: Reg) -> ValueRegs;
32     fn value_regs(&mut self, arg0: Reg, arg1: Reg) -> ValueRegs;
33     fn value_regs_invalid(&mut self) -> ValueRegs;
34     fn output_none(&mut self) -> InstOutput;
35     fn output(&mut self, arg0: ValueRegs) -> InstOutput;
36     fn output_pair(&mut self, arg0: ValueRegs, arg1: ValueRegs) -> InstOutput;
37     fn output_builder_new(&mut self) -> InstOutputBuilder;
38     fn output_builder_push(&mut self, arg0: &InstOutputBuilder, arg1: ValueRegs) -> Unit;
39     fn output_builder_finish(&mut self, arg0: &InstOutputBuilder) -> InstOutput;
40     fn temp_writable_reg(&mut self, arg0: Type) -> WritableReg;
41     fn invalid_reg_etor(&mut self, arg0: Reg) -> Option<()>;
42     fn invalid_reg(&mut self) -> Reg;
43     fn valid_reg(&mut self, arg0: Reg) -> Option<()>;
44     fn put_in_reg(&mut self, arg0: Value) -> Reg;
45     fn put_in_regs(&mut self, arg0: Value) -> ValueRegs;
46     fn ensure_in_vreg(&mut self, arg0: Reg, arg1: Type) -> Reg;
47     fn value_regs_get(&mut self, arg0: ValueRegs, arg1: usize) -> Reg;
48     fn u8_as_u32(&mut self, arg0: u8) -> Option<u32>;
49     fn u8_as_u64(&mut self, arg0: u8) -> Option<u64>;
50     fn u16_as_u64(&mut self, arg0: u16) -> Option<u64>;
51     fn u32_as_u64(&mut self, arg0: u32) -> Option<u64>;
52     fn i64_as_u64(&mut self, arg0: i64) -> Option<u64>;
53     fn u64_add(&mut self, arg0: u64, arg1: u64) -> Option<u64>;
54     fn u64_sub(&mut self, arg0: u64, arg1: u64) -> Option<u64>;
55     fn u64_and(&mut self, arg0: u64, arg1: u64) -> Option<u64>;
56     fn ty_bits(&mut self, arg0: Type) -> Option<u8>;
57     fn ty_bits_u16(&mut self, arg0: Type) -> u16;
58     fn ty_bits_u64(&mut self, arg0: Type) -> u64;
59     fn ty_mask(&mut self, arg0: Type) -> u64;
60     fn ty_bytes(&mut self, arg0: Type) -> u16;
61     fn lane_type(&mut self, arg0: Type) -> Type;
62     fn fits_in_16(&mut self, arg0: Type) -> Option<Type>;
63     fn fits_in_32(&mut self, arg0: Type) -> Option<Type>;
64     fn fits_in_64(&mut self, arg0: Type) -> Option<Type>;
65     fn ty_32_or_64(&mut self, arg0: Type) -> Option<Type>;
66     fn ty_8_or_16(&mut self, arg0: Type) -> Option<Type>;
67     fn ty_int_bool_64(&mut self, arg0: Type) -> Option<Type>;
68     fn ty_int_bool_ref_64(&mut self, arg0: Type) -> Option<Type>;
69     fn ty_int_bool_128(&mut self, arg0: Type) -> Option<Type>;
70     fn ty_scalar_float(&mut self, arg0: Type) -> Option<Type>;
71     fn ty_vec128(&mut self, arg0: Type) -> Option<Type>;
72     fn ty_vec128_int(&mut self, arg0: Type) -> Option<Type>;
73     fn not_i64x2(&mut self, arg0: Type) -> Option<()>;
74     fn value_list_slice(&mut self, arg0: ValueList) -> ValueSlice;
75     fn value_slice_empty(&mut self, arg0: ValueSlice) -> Option<()>;
76     fn value_slice_unwrap(&mut self, arg0: ValueSlice) -> Option<(Value, ValueSlice)>;
77     fn value_slice_len(&mut self, arg0: ValueSlice) -> usize;
78     fn value_slice_get(&mut self, arg0: ValueSlice, arg1: usize) -> Value;
79     fn writable_reg_to_reg(&mut self, arg0: WritableReg) -> Reg;
80     fn u8_from_uimm8(&mut self, arg0: Uimm8) -> u8;
81     fn u64_from_imm64(&mut self, arg0: Imm64) -> u64;
82     fn nonzero_u64_from_imm64(&mut self, arg0: Imm64) -> Option<u64>;
83     fn u64_from_ieee32(&mut self, arg0: Ieee32) -> u64;
84     fn u64_from_ieee64(&mut self, arg0: Ieee64) -> u64;
85     fn inst_results(&mut self, arg0: Inst) -> ValueSlice;
86     fn first_result(&mut self, arg0: Inst) -> Option<Value>;
87     fn inst_data(&mut self, arg0: Inst) -> InstructionData;
88     fn value_type(&mut self, arg0: Value) -> Type;
89     fn multi_lane(&mut self, arg0: Type) -> Option<(u8, u16)>;
90     fn def_inst(&mut self, arg0: Value) -> Option<Inst>;
91     fn offset32_to_u32(&mut self, arg0: Offset32) -> u32;
92     fn emit(&mut self, arg0: &MInst) -> Unit;
93     fn trap_code_division_by_zero(&mut self) -> TrapCode;
94     fn trap_code_integer_overflow(&mut self) -> TrapCode;
95     fn trap_code_bad_conversion_to_integer(&mut self) -> TrapCode;
96     fn avoid_div_traps(&mut self, arg0: Type) -> Option<()>;
97     fn func_ref_data(&mut self, arg0: FuncRef) -> (SigRef, ExternalName, RelocDistance);
98     fn symbol_value_data(
99         &mut self,
100         arg0: GlobalValue,
101     ) -> Option<(ExternalName, RelocDistance, i64)>;
102     fn reloc_distance_near(&mut self, arg0: RelocDistance) -> Option<()>;
103     fn operand_size_of_type_32_64(&mut self, arg0: Type) -> OperandSize;
104     fn raw_operand_size_of_type(&mut self, arg0: Type) -> OperandSize;
105     fn put_in_reg_mem_imm(&mut self, arg0: Value) -> RegMemImm;
106     fn put_in_reg_mem(&mut self, arg0: Value) -> RegMem;
107     fn synthetic_amode_to_reg_mem(&mut self, arg0: &SyntheticAmode) -> RegMem;
108     fn amode_to_synthetic_amode(&mut self, arg0: &Amode) -> SyntheticAmode;
109     fn amode_with_flags(&mut self, arg0: &Amode, arg1: MemFlags) -> Amode;
110     fn amode_imm_reg(&mut self, arg0: u32, arg1: Gpr) -> Amode;
111     fn amode_imm_reg_reg_shift(&mut self, arg0: u32, arg1: Gpr, arg2: Gpr, arg3: u8) -> Amode;
112     fn sum_extend_fits_in_32_bits(
113         &mut self,
114         arg0: Type,
115         arg1: Imm64,
116         arg2: Offset32,
117     ) -> Option<u32>;
118     fn amode_offset(&mut self, arg0: &Amode, arg1: u32) -> Amode;
119     fn put_masked_in_imm8_gpr(&mut self, arg0: Value, arg1: Type) -> Imm8Gpr;
120     fn intcc_to_cc(&mut self, arg0: &IntCC) -> CC;
121     fn encode_fcmp_imm(&mut self, arg0: &FcmpImm) -> u8;
122     fn imm8_reg_to_imm8_gpr(&mut self, arg0: &Imm8Reg) -> Imm8Gpr;
123     fn writable_gpr_to_reg(&mut self, arg0: WritableGpr) -> WritableReg;
124     fn writable_xmm_to_reg(&mut self, arg0: WritableXmm) -> WritableReg;
125     fn writable_reg_to_xmm(&mut self, arg0: WritableReg) -> WritableXmm;
126     fn writable_xmm_to_xmm(&mut self, arg0: WritableXmm) -> Xmm;
127     fn writable_gpr_to_gpr(&mut self, arg0: WritableGpr) -> Gpr;
128     fn gpr_to_reg(&mut self, arg0: Gpr) -> Reg;
129     fn gpr_to_gpr_mem(&mut self, arg0: Gpr) -> GprMem;
130     fn gpr_to_gpr_mem_imm(&mut self, arg0: Gpr) -> GprMemImm;
131     fn xmm_to_reg(&mut self, arg0: Xmm) -> Reg;
132     fn xmm_to_xmm_mem_imm(&mut self, arg0: Xmm) -> XmmMemImm;
133     fn temp_writable_gpr(&mut self) -> WritableGpr;
134     fn temp_writable_xmm(&mut self) -> WritableXmm;
135     fn reg_mem_to_xmm_mem(&mut self, arg0: &RegMem) -> XmmMem;
136     fn gpr_mem_imm_new(&mut self, arg0: &RegMemImm) -> GprMemImm;
137     fn xmm_mem_imm_new(&mut self, arg0: &RegMemImm) -> XmmMemImm;
138     fn xmm_to_xmm_mem(&mut self, arg0: Xmm) -> XmmMem;
139     fn xmm_mem_to_reg_mem(&mut self, arg0: &XmmMem) -> RegMem;
140     fn gpr_mem_to_reg_mem(&mut self, arg0: &GprMem) -> RegMem;
141     fn xmm_new(&mut self, arg0: Reg) -> Xmm;
142     fn gpr_new(&mut self, arg0: Reg) -> Gpr;
143     fn reg_mem_to_gpr_mem(&mut self, arg0: &RegMem) -> GprMem;
144     fn reg_to_gpr_mem(&mut self, arg0: Reg) -> GprMem;
145     fn gpr_to_imm8_gpr(&mut self, arg0: Gpr) -> Imm8Gpr;
146     fn imm8_to_imm8_gpr(&mut self, arg0: u8) -> Imm8Gpr;
147     fn xmm0(&mut self) -> WritableXmm;
148     fn is_xmm_type(&mut self, arg0: Type) -> Option<Type>;
149     fn is_gpr_type(&mut self, arg0: Type) -> Option<Type>;
150     fn is_single_register_type(&mut self, arg0: Type) -> Option<Type>;
151     fn avx512vl_enabled(&mut self, arg0: Type) -> Option<()>;
152     fn avx512dq_enabled(&mut self, arg0: Type) -> Option<()>;
153     fn avx512f_enabled(&mut self, arg0: Type) -> Option<()>;
154     fn avx512bitalg_enabled(&mut self, arg0: Type) -> Option<()>;
155     fn use_lzcnt(&mut self, arg0: Type) -> Option<()>;
156     fn use_bmi1(&mut self, arg0: Type) -> Option<()>;
157     fn use_popcnt(&mut self, arg0: Type) -> Option<()>;
158     fn imm8_from_value(&mut self, arg0: Value) -> Option<Imm8Reg>;
159     fn const_to_type_masked_imm8(&mut self, arg0: u64, arg1: Type) -> Imm8Gpr;
160     fn simm32_from_value(&mut self, arg0: Value) -> Option<GprMemImm>;
161     fn simm32_from_imm64(&mut self, arg0: Imm64) -> Option<GprMemImm>;
162     fn sinkable_load(&mut self, arg0: Value) -> Option<SinkableLoad>;
163     fn sink_load(&mut self, arg0: &SinkableLoad) -> RegMemImm;
164     fn ext_mode(&mut self, arg0: u16, arg1: u16) -> ExtMode;
165     fn nonzero_u64_fits_in_u32(&mut self, arg0: u64) -> Option<u64>;
166     fn ishl_i8x16_mask_for_const(&mut self, arg0: u32) -> SyntheticAmode;
167     fn ishl_i8x16_mask_table(&mut self) -> SyntheticAmode;
168     fn ushr_i8x16_mask_for_const(&mut self, arg0: u32) -> SyntheticAmode;
169     fn ushr_i8x16_mask_table(&mut self) -> SyntheticAmode;
170     fn sse_insertps_lane_imm(&mut self, arg0: u8) -> u8;
171     fn popcount_4bit_table(&mut self) -> VCodeConstant;
172     fn popcount_low_mask(&mut self) -> VCodeConstant;
173 }
174 
175 /// Internal type SideEffectNoResult: defined at src/prelude.isle line 447.
176 #[derive(Clone, Debug)]
177 pub enum SideEffectNoResult {
178     Inst { inst: MInst },
179     Inst2 { inst1: MInst, inst2: MInst },
180 }
181 
182 /// Internal type ProducesFlags: defined at src/prelude.isle line 474.
183 #[derive(Clone, Debug)]
184 pub enum ProducesFlags {
185     ProducesFlagsSideEffect { inst: MInst },
186     ProducesFlagsReturnsReg { inst: MInst, result: Reg },
187     ProducesFlagsReturnsResultWithConsumer { inst: MInst, result: Reg },
188 }
189 
190 /// Internal type ConsumesFlags: defined at src/prelude.isle line 485.
191 #[derive(Clone, Debug)]
192 pub enum ConsumesFlags {
193     ConsumesFlagsReturnsResultWithProducer {
194         inst: MInst,
195         result: Reg,
196     },
197     ConsumesFlagsReturnsReg {
198         inst: MInst,
199         result: Reg,
200     },
201     ConsumesFlagsTwiceReturnsValueRegs {
202         inst1: MInst,
203         inst2: MInst,
204         result: ValueRegs,
205     },
206     ConsumesFlagsFourTimesReturnsValueRegs {
207         inst1: MInst,
208         inst2: MInst,
209         inst3: MInst,
210         inst4: MInst,
211         result: ValueRegs,
212     },
213 }
214 
215 /// Internal type MInst: defined at src/isa/x64/inst.isle line 8.
216 #[derive(Clone)]
217 pub enum MInst {
218     Nop {
219         len: u8,
220     },
221     AluRmiR {
222         size: OperandSize,
223         op: AluRmiROpcode,
224         src1: Gpr,
225         src2: GprMemImm,
226         dst: WritableGpr,
227     },
228     AluRM {
229         size: OperandSize,
230         op: AluRmiROpcode,
231         src1_dst: SyntheticAmode,
232         src2: Gpr,
233     },
234     UnaryRmR {
235         size: OperandSize,
236         op: UnaryRmROpcode,
237         src: GprMem,
238         dst: WritableGpr,
239     },
240     Not {
241         size: OperandSize,
242         src: Gpr,
243         dst: WritableGpr,
244     },
245     Neg {
246         size: OperandSize,
247         src: Gpr,
248         dst: WritableGpr,
249     },
250     Div {
251         size: OperandSize,
252         signed: bool,
253         divisor: GprMem,
254         dividend_lo: Gpr,
255         dividend_hi: Gpr,
256         dst_quotient: WritableGpr,
257         dst_remainder: WritableGpr,
258     },
259     MulHi {
260         size: OperandSize,
261         signed: bool,
262         src1: Gpr,
263         src2: GprMem,
264         dst_lo: WritableGpr,
265         dst_hi: WritableGpr,
266     },
267     CheckedDivOrRemSeq {
268         kind: DivOrRemKind,
269         size: OperandSize,
270         dividend_lo: Gpr,
271         dividend_hi: Gpr,
272         divisor: WritableGpr,
273         dst_quotient: WritableGpr,
274         dst_remainder: WritableGpr,
275         tmp: OptionWritableGpr,
276     },
277     SignExtendData {
278         size: OperandSize,
279         src: Gpr,
280         dst: WritableGpr,
281     },
282     Imm {
283         dst_size: OperandSize,
284         simm64: u64,
285         dst: WritableGpr,
286     },
287     MovRR {
288         size: OperandSize,
289         src: Gpr,
290         dst: WritableGpr,
291     },
292     MovzxRmR {
293         ext_mode: ExtMode,
294         src: GprMem,
295         dst: WritableGpr,
296     },
297     Mov64MR {
298         src: SyntheticAmode,
299         dst: WritableGpr,
300     },
301     LoadEffectiveAddress {
302         addr: SyntheticAmode,
303         dst: WritableGpr,
304     },
305     MovsxRmR {
306         ext_mode: ExtMode,
307         src: GprMem,
308         dst: WritableGpr,
309     },
310     MovRM {
311         size: OperandSize,
312         src: Gpr,
313         dst: SyntheticAmode,
314     },
315     ShiftR {
316         size: OperandSize,
317         kind: ShiftKind,
318         src: Gpr,
319         num_bits: Imm8Gpr,
320         dst: WritableGpr,
321     },
322     XmmRmiReg {
323         opcode: SseOpcode,
324         src1: Xmm,
325         src2: XmmMemImm,
326         dst: WritableXmm,
327     },
328     CmpRmiR {
329         size: OperandSize,
330         opcode: CmpOpcode,
331         src: GprMemImm,
332         dst: Gpr,
333     },
334     Setcc {
335         cc: CC,
336         dst: WritableGpr,
337     },
338     Cmove {
339         size: OperandSize,
340         cc: CC,
341         consequent: GprMem,
342         alternative: Gpr,
343         dst: WritableGpr,
344     },
345     XmmCmove {
346         size: OperandSize,
347         cc: CC,
348         consequent: XmmMem,
349         alternative: Xmm,
350         dst: WritableXmm,
351     },
352     Push64 {
353         src: GprMemImm,
354     },
355     Pop64 {
356         dst: WritableGpr,
357     },
358     XmmRmR {
359         op: SseOpcode,
360         src1: Xmm,
361         src2: XmmMem,
362         dst: WritableXmm,
363     },
364     XmmRmREvex {
365         op: Avx512Opcode,
366         src1: XmmMem,
367         src2: Xmm,
368         dst: WritableXmm,
369     },
370     XmmUnaryRmR {
371         op: SseOpcode,
372         src: XmmMem,
373         dst: WritableXmm,
374     },
375     XmmUnaryRmREvex {
376         op: Avx512Opcode,
377         src: XmmMem,
378         dst: WritableXmm,
379     },
380     XmmMovRM {
381         op: SseOpcode,
382         src: Reg,
383         dst: SyntheticAmode,
384     },
385     XmmLoadConst {
386         src: VCodeConstant,
387         dst: WritableReg,
388         ty: Type,
389     },
390     XmmToGpr {
391         op: SseOpcode,
392         src: Xmm,
393         dst: WritableGpr,
394         dst_size: OperandSize,
395     },
396     GprToXmm {
397         op: SseOpcode,
398         src: GprMem,
399         dst: WritableXmm,
400         src_size: OperandSize,
401     },
402     CvtUint64ToFloatSeq {
403         dst_size: OperandSize,
404         src: WritableGpr,
405         dst: WritableXmm,
406         tmp_gpr1: WritableGpr,
407         tmp_gpr2: WritableGpr,
408     },
409     CvtFloatToSintSeq {
410         dst_size: OperandSize,
411         src_size: OperandSize,
412         is_saturating: bool,
413         src: WritableXmm,
414         dst: WritableGpr,
415         tmp_gpr: WritableGpr,
416         tmp_xmm: WritableXmm,
417     },
418     CvtFloatToUintSeq {
419         dst_size: OperandSize,
420         src_size: OperandSize,
421         is_saturating: bool,
422         src: WritableXmm,
423         dst: WritableGpr,
424         tmp_gpr: WritableGpr,
425         tmp_xmm: WritableXmm,
426     },
427     XmmMinMaxSeq {
428         size: OperandSize,
429         is_min: bool,
430         lhs: Xmm,
431         rhs: Xmm,
432         dst: WritableXmm,
433     },
434     XmmCmpRmR {
435         op: SseOpcode,
436         src: XmmMem,
437         dst: Xmm,
438     },
439     XmmRmRImm {
440         op: SseOpcode,
441         src1: Reg,
442         src2: RegMem,
443         dst: WritableReg,
444         imm: u8,
445         size: OperandSize,
446     },
447     CallKnown {
448         dest: ExternalName,
449         uses: VecReg,
450         defs: VecWritableReg,
451         opcode: Opcode,
452     },
453     CallUnknown {
454         dest: RegMem,
455         uses: VecReg,
456         defs: VecWritableReg,
457         opcode: Opcode,
458     },
459     Ret {
460         rets: VecReg,
461     },
462     EpiloguePlaceholder,
463     JmpKnown {
464         dst: MachLabel,
465     },
466     JmpIf {
467         cc: CC,
468         taken: MachLabel,
469     },
470     JmpCond {
471         cc: CC,
472         taken: MachLabel,
473         not_taken: MachLabel,
474     },
475     JmpTableSeq {
476         idx: Reg,
477         tmp1: WritableReg,
478         tmp2: WritableReg,
479         default_target: MachLabel,
480         targets: VecMachLabel,
481         targets_for_term: VecMachLabel,
482     },
483     JmpUnknown {
484         target: RegMem,
485     },
486     TrapIf {
487         cc: CC,
488         trap_code: TrapCode,
489     },
490     Hlt,
491     Ud2 {
492         trap_code: TrapCode,
493     },
494     LoadExtName {
495         dst: WritableReg,
496         name: BoxExternalName,
497         offset: i64,
498     },
499     LockCmpxchg {
500         ty: Type,
501         replacement: Reg,
502         expected: Reg,
503         mem: SyntheticAmode,
504         dst_old: WritableReg,
505     },
506     AtomicRmwSeq {
507         ty: Type,
508         op: AtomicRmwOp,
509         address: Reg,
510         operand: Reg,
511         temp: WritableReg,
512         dst_old: WritableReg,
513     },
514     Fence {
515         kind: FenceKind,
516     },
517     VirtualSPOffsetAdj {
518         offset: i64,
519     },
520     XmmUninitializedValue {
521         dst: WritableXmm,
522     },
523     ElfTlsGetAddr {
524         symbol: ExternalName,
525     },
526     MachOTlsGetAddr {
527         symbol: ExternalName,
528     },
529     Unwind {
530         inst: UnwindInst,
531     },
532     DummyUse {
533         reg: Reg,
534     },
535 }
536 
537 /// Internal type Amode: defined at src/isa/x64/inst.isle line 770.
538 #[derive(Clone, Debug)]
539 pub enum Amode {
540     ImmReg {
541         simm32: u32,
542         base: Reg,
543         flags: MemFlags,
544     },
545     ImmRegRegShift {
546         simm32: u32,
547         base: Gpr,
548         index: Gpr,
549         shift: u8,
550         flags: MemFlags,
551     },
552     RipRelative {
553         target: MachLabel,
554     },
555 }
556 
557 /// Internal type ExtendKind: defined at src/isa/x64/inst.isle line 1354.
558 #[derive(Copy, Clone, PartialEq, Eq, Debug)]
559 pub enum ExtendKind {
560     Sign,
561     Zero,
562 }
563 
564 // Generated as internal constructor for term output_reg.
565 pub fn constructor_output_reg<C: Context>(ctx: &mut C, arg0: Reg) -> Option<InstOutput> {
566     let pattern0_0 = arg0;
567     // Rule at src/prelude.isle line 113.
568     let expr0_0 = C::value_reg(ctx, pattern0_0);
569     let expr1_0 = C::output(ctx, expr0_0);
570     return Some(expr1_0);
571 }
572 
573 // Generated as internal constructor for term output_value.
574 pub fn constructor_output_value<C: Context>(ctx: &mut C, arg0: Value) -> Option<InstOutput> {
575     let pattern0_0 = arg0;
576     // Rule at src/prelude.isle line 117.
577     let expr0_0 = C::put_in_regs(ctx, pattern0_0);
578     let expr1_0 = C::output(ctx, expr0_0);
579     return Some(expr1_0);
580 }
581 
582 // Generated as internal constructor for term temp_reg.
583 pub fn constructor_temp_reg<C: Context>(ctx: &mut C, arg0: Type) -> Option<Reg> {
584     let pattern0_0 = arg0;
585     // Rule at src/prelude.isle line 137.
586     let expr0_0 = C::temp_writable_reg(ctx, pattern0_0);
587     let expr1_0 = C::writable_reg_to_reg(ctx, expr0_0);
588     return Some(expr1_0);
589 }
590 
591 // Generated as internal constructor for term lo_reg.
592 pub fn constructor_lo_reg<C: Context>(ctx: &mut C, arg0: Value) -> Option<Reg> {
593     let pattern0_0 = arg0;
594     // Rule at src/prelude.isle line 182.
595     let expr0_0 = C::put_in_regs(ctx, pattern0_0);
596     let expr1_0: usize = 0;
597     let expr2_0 = C::value_regs_get(ctx, expr0_0, expr1_0);
598     return Some(expr2_0);
599 }
600 
601 // Generated as internal constructor for term side_effect.
602 pub fn constructor_side_effect<C: Context>(
603     ctx: &mut C,
604     arg0: &SideEffectNoResult,
605 ) -> Option<InstOutput> {
606     let pattern0_0 = arg0;
607     match pattern0_0 {
608         &SideEffectNoResult::Inst {
609             inst: ref pattern1_0,
610         } => {
611             // Rule at src/prelude.isle line 455.
612             let expr0_0 = C::emit(ctx, pattern1_0);
613             let expr1_0 = C::output_none(ctx);
614             return Some(expr1_0);
615         }
616         &SideEffectNoResult::Inst2 {
617             inst1: ref pattern1_0,
618             inst2: ref pattern1_1,
619         } => {
620             // Rule at src/prelude.isle line 458.
621             let expr0_0 = C::emit(ctx, pattern1_0);
622             let expr1_0 = C::emit(ctx, pattern1_1);
623             let expr2_0 = C::output_none(ctx);
624             return Some(expr2_0);
625         }
626         _ => {}
627     }
628     return None;
629 }
630 
631 // Generated as internal constructor for term side_effect_concat.
632 pub fn constructor_side_effect_concat<C: Context>(
633     ctx: &mut C,
634     arg0: &SideEffectNoResult,
635     arg1: &SideEffectNoResult,
636 ) -> Option<SideEffectNoResult> {
637     let pattern0_0 = arg0;
638     if let &SideEffectNoResult::Inst {
639         inst: ref pattern1_0,
640     } = pattern0_0
641     {
642         let pattern2_0 = arg1;
643         if let &SideEffectNoResult::Inst {
644             inst: ref pattern3_0,
645         } = pattern2_0
646         {
647             // Rule at src/prelude.isle line 464.
648             let expr0_0 = SideEffectNoResult::Inst2 {
649                 inst1: pattern1_0.clone(),
650                 inst2: pattern3_0.clone(),
651             };
652             return Some(expr0_0);
653         }
654     }
655     return None;
656 }
657 
658 // Generated as internal constructor for term produces_flags_get_reg.
659 pub fn constructor_produces_flags_get_reg<C: Context>(
660     ctx: &mut C,
661     arg0: &ProducesFlags,
662 ) -> Option<Reg> {
663     let pattern0_0 = arg0;
664     if let &ProducesFlags::ProducesFlagsReturnsReg {
665         inst: ref pattern1_0,
666         result: pattern1_1,
667     } = pattern0_0
668     {
669         // Rule at src/prelude.isle line 501.
670         return Some(pattern1_1);
671     }
672     return None;
673 }
674 
675 // Generated as internal constructor for term produces_flags_ignore.
676 pub fn constructor_produces_flags_ignore<C: Context>(
677     ctx: &mut C,
678     arg0: &ProducesFlags,
679 ) -> Option<ProducesFlags> {
680     let pattern0_0 = arg0;
681     match pattern0_0 {
682         &ProducesFlags::ProducesFlagsReturnsReg {
683             inst: ref pattern1_0,
684             result: pattern1_1,
685         } => {
686             // Rule at src/prelude.isle line 506.
687             let expr0_0 = ProducesFlags::ProducesFlagsSideEffect {
688                 inst: pattern1_0.clone(),
689             };
690             return Some(expr0_0);
691         }
692         &ProducesFlags::ProducesFlagsReturnsResultWithConsumer {
693             inst: ref pattern1_0,
694             result: pattern1_1,
695         } => {
696             // Rule at src/prelude.isle line 508.
697             let expr0_0 = ProducesFlags::ProducesFlagsSideEffect {
698                 inst: pattern1_0.clone(),
699             };
700             return Some(expr0_0);
701         }
702         _ => {}
703     }
704     return None;
705 }
706 
707 // Generated as internal constructor for term consumes_flags_concat.
708 pub fn constructor_consumes_flags_concat<C: Context>(
709     ctx: &mut C,
710     arg0: &ConsumesFlags,
711     arg1: &ConsumesFlags,
712 ) -> Option<ConsumesFlags> {
713     let pattern0_0 = arg0;
714     if let &ConsumesFlags::ConsumesFlagsReturnsReg {
715         inst: ref pattern1_0,
716         result: pattern1_1,
717     } = pattern0_0
718     {
719         let pattern2_0 = arg1;
720         if let &ConsumesFlags::ConsumesFlagsReturnsReg {
721             inst: ref pattern3_0,
722             result: pattern3_1,
723         } = pattern2_0
724         {
725             // Rule at src/prelude.isle line 515.
726             let expr0_0 = C::value_regs(ctx, pattern1_1, pattern3_1);
727             let expr1_0 = ConsumesFlags::ConsumesFlagsTwiceReturnsValueRegs {
728                 inst1: pattern1_0.clone(),
729                 inst2: pattern3_0.clone(),
730                 result: expr0_0,
731             };
732             return Some(expr1_0);
733         }
734     }
735     return None;
736 }
737 
738 // Generated as internal constructor for term with_flags.
739 pub fn constructor_with_flags<C: Context>(
740     ctx: &mut C,
741     arg0: &ProducesFlags,
742     arg1: &ConsumesFlags,
743 ) -> Option<ValueRegs> {
744     let pattern0_0 = arg0;
745     match pattern0_0 {
746         &ProducesFlags::ProducesFlagsSideEffect {
747             inst: ref pattern1_0,
748         } => {
749             let pattern2_0 = arg1;
750             match pattern2_0 {
751                 &ConsumesFlags::ConsumesFlagsReturnsReg {
752                     inst: ref pattern3_0,
753                     result: pattern3_1,
754                 } => {
755                     // Rule at src/prelude.isle line 540.
756                     let expr0_0 = C::emit(ctx, pattern1_0);
757                     let expr1_0 = C::emit(ctx, pattern3_0);
758                     let expr2_0 = C::value_reg(ctx, pattern3_1);
759                     return Some(expr2_0);
760                 }
761                 &ConsumesFlags::ConsumesFlagsTwiceReturnsValueRegs {
762                     inst1: ref pattern3_0,
763                     inst2: ref pattern3_1,
764                     result: pattern3_2,
765                 } => {
766                     // Rule at src/prelude.isle line 546.
767                     let expr0_0 = C::emit(ctx, pattern1_0);
768                     let expr1_0 = C::emit(ctx, pattern3_0);
769                     let expr2_0 = C::emit(ctx, pattern3_1);
770                     return Some(pattern3_2);
771                 }
772                 &ConsumesFlags::ConsumesFlagsFourTimesReturnsValueRegs {
773                     inst1: ref pattern3_0,
774                     inst2: ref pattern3_1,
775                     inst3: ref pattern3_2,
776                     inst4: ref pattern3_3,
777                     result: pattern3_4,
778                 } => {
779                     // Rule at src/prelude.isle line 558.
780                     let expr0_0 = C::emit(ctx, pattern1_0);
781                     let expr1_0 = C::emit(ctx, pattern3_0);
782                     let expr2_0 = C::emit(ctx, pattern3_1);
783                     let expr3_0 = C::emit(ctx, pattern3_2);
784                     let expr4_0 = C::emit(ctx, pattern3_3);
785                     return Some(pattern3_4);
786                 }
787                 _ => {}
788             }
789         }
790         &ProducesFlags::ProducesFlagsReturnsResultWithConsumer {
791             inst: ref pattern1_0,
792             result: pattern1_1,
793         } => {
794             let pattern2_0 = arg1;
795             if let &ConsumesFlags::ConsumesFlagsReturnsResultWithProducer {
796                 inst: ref pattern3_0,
797                 result: pattern3_1,
798             } = pattern2_0
799             {
800                 // Rule at src/prelude.isle line 534.
801                 let expr0_0 = C::emit(ctx, pattern1_0);
802                 let expr1_0 = C::emit(ctx, pattern3_0);
803                 let expr2_0 = C::value_regs(ctx, pattern1_1, pattern3_1);
804                 return Some(expr2_0);
805             }
806         }
807         _ => {}
808     }
809     return None;
810 }
811 
812 // Generated as internal constructor for term with_flags_reg.
813 pub fn constructor_with_flags_reg<C: Context>(
814     ctx: &mut C,
815     arg0: &ProducesFlags,
816     arg1: &ConsumesFlags,
817 ) -> Option<Reg> {
818     let pattern0_0 = arg0;
819     let pattern1_0 = arg1;
820     // Rule at src/prelude.isle line 575.
821     let expr0_0 = constructor_with_flags(ctx, pattern0_0, pattern1_0)?;
822     let expr1_0: usize = 0;
823     let expr2_0 = C::value_regs_get(ctx, expr0_0, expr1_0);
824     return Some(expr2_0);
825 }
826 
827 // Generated as internal constructor for term operand_size_bits.
828 pub fn constructor_operand_size_bits<C: Context>(ctx: &mut C, arg0: &OperandSize) -> Option<u16> {
829     let pattern0_0 = arg0;
830     match pattern0_0 {
831         &OperandSize::Size8 => {
832             // Rule at src/isa/x64/inst.isle line 517.
833             let expr0_0: u16 = 8;
834             return Some(expr0_0);
835         }
836         &OperandSize::Size16 => {
837             // Rule at src/isa/x64/inst.isle line 518.
838             let expr0_0: u16 = 16;
839             return Some(expr0_0);
840         }
841         &OperandSize::Size32 => {
842             // Rule at src/isa/x64/inst.isle line 519.
843             let expr0_0: u16 = 32;
844             return Some(expr0_0);
845         }
846         &OperandSize::Size64 => {
847             // Rule at src/isa/x64/inst.isle line 520.
848             let expr0_0: u16 = 64;
849             return Some(expr0_0);
850         }
851         _ => {}
852     }
853     return None;
854 }
855 
856 // Generated as internal constructor for term amode_imm_reg_flags.
857 pub fn constructor_amode_imm_reg_flags<C: Context>(
858     ctx: &mut C,
859     arg0: u32,
860     arg1: Gpr,
861     arg2: MemFlags,
862 ) -> Option<Amode> {
863     let pattern0_0 = arg0;
864     let pattern1_0 = arg1;
865     let pattern2_0 = arg2;
866     // Rule at src/isa/x64/inst.isle line 798.
867     let expr0_0 = C::amode_imm_reg(ctx, pattern0_0, pattern1_0);
868     let expr1_0 = C::amode_with_flags(ctx, &expr0_0, pattern2_0);
869     return Some(expr1_0);
870 }
871 
872 // Generated as internal constructor for term amode_imm_reg_reg_shift_flags.
873 pub fn constructor_amode_imm_reg_reg_shift_flags<C: Context>(
874     ctx: &mut C,
875     arg0: u32,
876     arg1: Gpr,
877     arg2: Gpr,
878     arg3: u8,
879     arg4: MemFlags,
880 ) -> Option<Amode> {
881     let pattern0_0 = arg0;
882     let pattern1_0 = arg1;
883     let pattern2_0 = arg2;
884     let pattern3_0 = arg3;
885     let pattern4_0 = arg4;
886     // Rule at src/isa/x64/inst.isle line 805.
887     let expr0_0 = C::amode_imm_reg_reg_shift(ctx, pattern0_0, pattern1_0, pattern2_0, pattern3_0);
888     let expr1_0 = C::amode_with_flags(ctx, &expr0_0, pattern4_0);
889     return Some(expr1_0);
890 }
891 
892 // Generated as internal constructor for term to_amode.
893 pub fn constructor_to_amode<C: Context>(
894     ctx: &mut C,
895     arg0: MemFlags,
896     arg1: Value,
897     arg2: Offset32,
898 ) -> Option<Amode> {
899     let pattern0_0 = arg0;
900     let pattern1_0 = arg1;
901     let pattern2_0 = arg2;
902     // Rule at src/isa/x64/inst.isle line 985.
903     let expr0_0 = constructor_amode_initial(ctx, pattern0_0, pattern2_0)?;
904     let expr1_0 = constructor_amode_add(ctx, &expr0_0, pattern1_0)?;
905     return Some(expr1_0);
906 }
907 
908 // Generated as internal constructor for term amode_initial.
909 pub fn constructor_amode_initial<C: Context>(
910     ctx: &mut C,
911     arg0: MemFlags,
912     arg1: Offset32,
913 ) -> Option<Amode> {
914     let pattern0_0 = arg0;
915     let pattern1_0 = arg1;
916     if let Some(pattern2_0) = C::offset32(ctx, pattern1_0) {
917         // Rule at src/isa/x64/inst.isle line 875.
918         let expr0_0 = C::invalid_reg(ctx);
919         let expr1_0 = Amode::ImmReg {
920             simm32: pattern2_0,
921             base: expr0_0,
922             flags: pattern0_0,
923         };
924         return Some(expr1_0);
925     }
926     return None;
927 }
928 
929 // Generated as internal constructor for term amode_add.
930 pub fn constructor_amode_add<C: Context>(ctx: &mut C, arg0: &Amode, arg1: Value) -> Option<Amode> {
931     let pattern0_0 = arg0;
932     match pattern0_0 {
933         &Amode::ImmReg {
934             simm32: pattern1_0,
935             base: pattern1_1,
936             flags: pattern1_2,
937         } => {
938             let pattern2_0 = arg1;
939             if let Some(pattern3_0) = C::def_inst(ctx, pattern2_0) {
940                 let pattern4_0 = C::inst_data(ctx, pattern3_0);
941                 match &pattern4_0 {
942                     &InstructionData::UnaryImm {
943                         opcode: ref pattern5_0,
944                         imm: pattern5_1,
945                     } => {
946                         if let &Opcode::Iconst = pattern5_0 {
947                             if let Some(pattern7_0) = C::simm32(ctx, pattern5_1) {
948                                 let mut closure8 = || {
949                                     let expr0_0 = C::s32_add_fallible(ctx, pattern1_0, pattern7_0)?;
950                                     return Some(expr0_0);
951                                 };
952                                 if let Some(pattern8_0) = closure8() {
953                                     // Rule at src/isa/x64/inst.isle line 943.
954                                     let expr0_0 = Amode::ImmReg {
955                                         simm32: pattern8_0,
956                                         base: pattern1_1,
957                                         flags: pattern1_2,
958                                     };
959                                     return Some(expr0_0);
960                                 }
961                             }
962                         }
963                     }
964                     &InstructionData::Unary {
965                         opcode: ref pattern5_0,
966                         arg: pattern5_1,
967                     } => {
968                         match pattern5_0 {
969                             &Opcode::Uextend => {
970                                 if let Some(pattern7_0) = C::def_inst(ctx, pattern5_1) {
971                                     let pattern8_0 = C::inst_data(ctx, pattern7_0);
972                                     if let &InstructionData::UnaryImm {
973                                         opcode: ref pattern9_0,
974                                         imm: pattern9_1,
975                                     } = &pattern8_0
976                                     {
977                                         if let &Opcode::Iconst = pattern9_0 {
978                                             if let Some(pattern11_0) = C::simm32(ctx, pattern9_1) {
979                                                 if let Some(pattern12_0) =
980                                                     C::u32_nonnegative(ctx, pattern11_0)
981                                                 {
982                                                     let mut closure13 = || {
983                                                         let expr0_0 = C::s32_add_fallible(
984                                                             ctx,
985                                                             pattern1_0,
986                                                             pattern12_0,
987                                                         )?;
988                                                         return Some(expr0_0);
989                                                     };
990                                                     if let Some(pattern13_0) = closure13() {
991                                                         // Rule at src/isa/x64/inst.isle line 956.
992                                                         let expr0_0 = Amode::ImmReg {
993                                                             simm32: pattern13_0,
994                                                             base: pattern1_1,
995                                                             flags: pattern1_2,
996                                                         };
997                                                         return Some(expr0_0);
998                                                     }
999                                                 }
1000                                             }
1001                                         }
1002                                     }
1003                                 }
1004                             }
1005                             &Opcode::Sextend => {
1006                                 if let Some(pattern7_0) = C::def_inst(ctx, pattern5_1) {
1007                                     let pattern8_0 = C::inst_data(ctx, pattern7_0);
1008                                     if let &InstructionData::UnaryImm {
1009                                         opcode: ref pattern9_0,
1010                                         imm: pattern9_1,
1011                                     } = &pattern8_0
1012                                     {
1013                                         if let &Opcode::Iconst = pattern9_0 {
1014                                             if let Some(pattern11_0) = C::simm32(ctx, pattern9_1) {
1015                                                 let mut closure12 = || {
1016                                                     let expr0_0 = C::s32_add_fallible(
1017                                                         ctx,
1018                                                         pattern1_0,
1019                                                         pattern11_0,
1020                                                     )?;
1021                                                     return Some(expr0_0);
1022                                                 };
1023                                                 if let Some(pattern12_0) = closure12() {
1024                                                     // Rule at src/isa/x64/inst.isle line 966.
1025                                                     let expr0_0 = Amode::ImmReg {
1026                                                         simm32: pattern12_0,
1027                                                         base: pattern1_1,
1028                                                         flags: pattern1_2,
1029                                                     };
1030                                                     return Some(expr0_0);
1031                                                 }
1032                                             }
1033                                         }
1034                                     }
1035                                 }
1036                             }
1037                             _ => {}
1038                         }
1039                     }
1040                     _ => {}
1041                 }
1042             }
1043         }
1044         &Amode::ImmRegRegShift {
1045             simm32: pattern1_0,
1046             base: pattern1_1,
1047             index: pattern1_2,
1048             shift: pattern1_3,
1049             flags: pattern1_4,
1050         } => {
1051             let pattern2_0 = arg1;
1052             if let Some(pattern3_0) = C::def_inst(ctx, pattern2_0) {
1053                 let pattern4_0 = C::inst_data(ctx, pattern3_0);
1054                 match &pattern4_0 {
1055                     &InstructionData::UnaryImm {
1056                         opcode: ref pattern5_0,
1057                         imm: pattern5_1,
1058                     } => {
1059                         if let &Opcode::Iconst = pattern5_0 {
1060                             if let Some(pattern7_0) = C::simm32(ctx, pattern5_1) {
1061                                 let mut closure8 = || {
1062                                     let expr0_0 = C::s32_add_fallible(ctx, pattern1_0, pattern7_0)?;
1063                                     return Some(expr0_0);
1064                                 };
1065                                 if let Some(pattern8_0) = closure8() {
1066                                     // Rule at src/isa/x64/inst.isle line 947.
1067                                     let expr0_0 = Amode::ImmRegRegShift {
1068                                         simm32: pattern8_0,
1069                                         base: pattern1_1,
1070                                         index: pattern1_2,
1071                                         shift: pattern1_3,
1072                                         flags: pattern1_4,
1073                                     };
1074                                     return Some(expr0_0);
1075                                 }
1076                             }
1077                         }
1078                     }
1079                     &InstructionData::Unary {
1080                         opcode: ref pattern5_0,
1081                         arg: pattern5_1,
1082                     } => {
1083                         match pattern5_0 {
1084                             &Opcode::Uextend => {
1085                                 if let Some(pattern7_0) = C::def_inst(ctx, pattern5_1) {
1086                                     let pattern8_0 = C::inst_data(ctx, pattern7_0);
1087                                     if let &InstructionData::UnaryImm {
1088                                         opcode: ref pattern9_0,
1089                                         imm: pattern9_1,
1090                                     } = &pattern8_0
1091                                     {
1092                                         if let &Opcode::Iconst = pattern9_0 {
1093                                             if let Some(pattern11_0) = C::simm32(ctx, pattern9_1) {
1094                                                 if let Some(pattern12_0) =
1095                                                     C::u32_nonnegative(ctx, pattern11_0)
1096                                                 {
1097                                                     let mut closure13 = || {
1098                                                         let expr0_0 = C::s32_add_fallible(
1099                                                             ctx,
1100                                                             pattern1_0,
1101                                                             pattern12_0,
1102                                                         )?;
1103                                                         return Some(expr0_0);
1104                                                     };
1105                                                     if let Some(pattern13_0) = closure13() {
1106                                                         // Rule at src/isa/x64/inst.isle line 960.
1107                                                         let expr0_0 = Amode::ImmRegRegShift {
1108                                                             simm32: pattern13_0,
1109                                                             base: pattern1_1,
1110                                                             index: pattern1_2,
1111                                                             shift: pattern1_3,
1112                                                             flags: pattern1_4,
1113                                                         };
1114                                                         return Some(expr0_0);
1115                                                     }
1116                                                 }
1117                                             }
1118                                         }
1119                                     }
1120                                 }
1121                             }
1122                             &Opcode::Sextend => {
1123                                 if let Some(pattern7_0) = C::def_inst(ctx, pattern5_1) {
1124                                     let pattern8_0 = C::inst_data(ctx, pattern7_0);
1125                                     if let &InstructionData::UnaryImm {
1126                                         opcode: ref pattern9_0,
1127                                         imm: pattern9_1,
1128                                     } = &pattern8_0
1129                                     {
1130                                         if let &Opcode::Iconst = pattern9_0 {
1131                                             if let Some(pattern11_0) = C::simm32(ctx, pattern9_1) {
1132                                                 let mut closure12 = || {
1133                                                     let expr0_0 = C::s32_add_fallible(
1134                                                         ctx,
1135                                                         pattern1_0,
1136                                                         pattern11_0,
1137                                                     )?;
1138                                                     return Some(expr0_0);
1139                                                 };
1140                                                 if let Some(pattern12_0) = closure12() {
1141                                                     // Rule at src/isa/x64/inst.isle line 970.
1142                                                     let expr0_0 = Amode::ImmRegRegShift {
1143                                                         simm32: pattern12_0,
1144                                                         base: pattern1_1,
1145                                                         index: pattern1_2,
1146                                                         shift: pattern1_3,
1147                                                         flags: pattern1_4,
1148                                                     };
1149                                                     return Some(expr0_0);
1150                                                 }
1151                                             }
1152                                         }
1153                                     }
1154                                 }
1155                             }
1156                             _ => {}
1157                         }
1158                     }
1159                     _ => {}
1160                 }
1161             }
1162         }
1163         _ => {}
1164     }
1165     let pattern0_0 = arg0;
1166     if let &Amode::ImmReg {
1167         simm32: pattern1_0,
1168         base: pattern1_1,
1169         flags: pattern1_2,
1170     } = pattern0_0
1171     {
1172         let pattern2_0 = arg1;
1173         if let Some(pattern3_0) = C::def_inst(ctx, pattern2_0) {
1174             let pattern4_0 = C::inst_data(ctx, pattern3_0);
1175             match &pattern4_0 {
1176                 &InstructionData::Binary {
1177                     opcode: ref pattern5_0,
1178                     args: ref pattern5_1,
1179                 } => {
1180                     if let &Opcode::Ishl = pattern5_0 {
1181                         let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
1182                         if let Some(pattern8_0) = C::def_inst(ctx, pattern7_1) {
1183                             let pattern9_0 = C::inst_data(ctx, pattern8_0);
1184                             if let &InstructionData::UnaryImm {
1185                                 opcode: ref pattern10_0,
1186                                 imm: pattern10_1,
1187                             } = &pattern9_0
1188                             {
1189                                 if let &Opcode::Iconst = pattern10_0 {
1190                                     if let Some(pattern12_0) = C::uimm8(ctx, pattern10_1) {
1191                                         let mut closure13 = || {
1192                                             return Some(pattern1_1);
1193                                         };
1194                                         if let Some(pattern13_0) = closure13() {
1195                                             if let Some(()) = C::valid_reg(ctx, pattern13_0) {
1196                                                 let mut closure15 = || {
1197                                                     let expr0_0 = C::u8_as_u32(ctx, pattern12_0)?;
1198                                                     let expr1_0: u32 = 3;
1199                                                     let expr2_0 =
1200                                                         C::u32_lteq(ctx, expr0_0, expr1_0)?;
1201                                                     return Some(expr2_0);
1202                                                 };
1203                                                 if let Some(pattern15_0) = closure15() {
1204                                                     // Rule at src/isa/x64/inst.isle line 914.
1205                                                     let expr0_0 = C::gpr_new(ctx, pattern1_1);
1206                                                     let expr1_0 =
1207                                                         constructor_put_in_gpr(ctx, pattern7_0)?;
1208                                                     let expr2_0 = Amode::ImmRegRegShift {
1209                                                         simm32: pattern1_0,
1210                                                         base: expr0_0,
1211                                                         index: expr1_0,
1212                                                         shift: pattern12_0,
1213                                                         flags: pattern1_2,
1214                                                     };
1215                                                     return Some(expr2_0);
1216                                                 }
1217                                             }
1218                                         }
1219                                     }
1220                                 }
1221                             }
1222                         }
1223                     }
1224                 }
1225                 &InstructionData::Unary {
1226                     opcode: ref pattern5_0,
1227                     arg: pattern5_1,
1228                 } => {
1229                     if let &Opcode::Uextend = pattern5_0 {
1230                         if let Some(pattern7_0) = C::def_inst(ctx, pattern5_1) {
1231                             let pattern8_0 = C::inst_data(ctx, pattern7_0);
1232                             if let &InstructionData::Binary {
1233                                 opcode: ref pattern9_0,
1234                                 args: ref pattern9_1,
1235                             } = &pattern8_0
1236                             {
1237                                 if let &Opcode::Ishl = pattern9_0 {
1238                                     let (pattern11_0, pattern11_1) =
1239                                         C::unpack_value_array_2(ctx, pattern9_1);
1240                                     if let Some(pattern12_0) = C::def_inst(ctx, pattern11_0) {
1241                                         let pattern13_0 = C::inst_data(ctx, pattern12_0);
1242                                         if let &InstructionData::Binary {
1243                                             opcode: ref pattern14_0,
1244                                             args: ref pattern14_1,
1245                                         } = &pattern13_0
1246                                         {
1247                                             if let &Opcode::Iadd = pattern14_0 {
1248                                                 let (pattern16_0, pattern16_1) =
1249                                                     C::unpack_value_array_2(ctx, pattern14_1);
1250                                                 if let Some(pattern17_0) =
1251                                                     C::def_inst(ctx, pattern11_1)
1252                                                 {
1253                                                     let pattern18_0 =
1254                                                         C::inst_data(ctx, pattern17_0);
1255                                                     if let &InstructionData::UnaryImm {
1256                                                         opcode: ref pattern19_0,
1257                                                         imm: pattern19_1,
1258                                                     } = &pattern18_0
1259                                                     {
1260                                                         if let &Opcode::Iconst = pattern19_0 {
1261                                                             if let Some(pattern21_0) =
1262                                                                 C::uimm8(ctx, pattern19_1)
1263                                                             {
1264                                                                 let mut closure22 = || {
1265                                                                     return Some(pattern1_1);
1266                                                                 };
1267                                                                 if let Some(pattern22_0) =
1268                                                                     closure22()
1269                                                                 {
1270                                                                     if let Some(()) = C::valid_reg(
1271                                                                         ctx,
1272                                                                         pattern22_0,
1273                                                                     ) {
1274                                                                         let mut closure24 = || {
1275                                                                             let expr0_0 =
1276                                                                                 C::u8_as_u32(
1277                                                                                     ctx,
1278                                                                                     pattern21_0,
1279                                                                                 )?;
1280                                                                             let expr1_0: u32 = 3;
1281                                                                             let expr2_0 =
1282                                                                                 C::u32_lteq(
1283                                                                                     ctx, expr0_0,
1284                                                                                     expr1_0,
1285                                                                                 )?;
1286                                                                             return Some(expr2_0);
1287                                                                         };
1288                                                                         if let Some(pattern24_0) =
1289                                                                             closure24()
1290                                                                         {
1291                                                                             // Rule at src/isa/x64/inst.isle line 929.
1292                                                                             let expr0_0 =
1293                                                                                 C::gpr_new(
1294                                                                                     ctx, pattern1_1,
1295                                                                                 );
1296                                                                             let expr1_0 = constructor_put_in_gpr(ctx, pattern11_0)?;
1297                                                                             let expr2_0 = Amode::ImmRegRegShift {
1298                                                                                 simm32: pattern1_0,
1299                                                                                 base: expr0_0,
1300                                                                                 index: expr1_0,
1301                                                                                 shift: pattern21_0,
1302                                                                                 flags: pattern1_2,
1303                                                                             };
1304                                                                             return Some(expr2_0);
1305                                                                         }
1306                                                                     }
1307                                                                 }
1308                                                             }
1309                                                         }
1310                                                     }
1311                                                 }
1312                                             }
1313                                         }
1314                                     }
1315                                     if let Some(pattern12_0) = C::def_inst(ctx, pattern11_1) {
1316                                         let pattern13_0 = C::inst_data(ctx, pattern12_0);
1317                                         if let &InstructionData::UnaryImm {
1318                                             opcode: ref pattern14_0,
1319                                             imm: pattern14_1,
1320                                         } = &pattern13_0
1321                                         {
1322                                             if let &Opcode::Iconst = pattern14_0 {
1323                                                 if let Some(pattern16_0) =
1324                                                     C::uimm8(ctx, pattern14_1)
1325                                                 {
1326                                                     let mut closure17 = || {
1327                                                         return Some(pattern1_1);
1328                                                     };
1329                                                     if let Some(pattern17_0) = closure17() {
1330                                                         if let Some(()) =
1331                                                             C::valid_reg(ctx, pattern17_0)
1332                                                         {
1333                                                             let mut closure19 = || {
1334                                                                 let expr0_0 =
1335                                                                     C::u8_as_u32(ctx, pattern16_0)?;
1336                                                                 let expr1_0: u32 = 3;
1337                                                                 let expr2_0 = C::u32_lteq(
1338                                                                     ctx, expr0_0, expr1_0,
1339                                                                 )?;
1340                                                                 return Some(expr2_0);
1341                                                             };
1342                                                             if let Some(pattern19_0) = closure19() {
1343                                                                 // Rule at src/isa/x64/inst.isle line 918.
1344                                                                 let expr0_0 =
1345                                                                     C::gpr_new(ctx, pattern1_1);
1346                                                                 let expr1_0: Type = I64;
1347                                                                 let expr2_0 = ExtendKind::Zero;
1348                                                                 let expr3_0 =
1349                                                                     constructor_extend_to_gpr(
1350                                                                         ctx,
1351                                                                         pattern11_0,
1352                                                                         expr1_0,
1353                                                                         &expr2_0,
1354                                                                     )?;
1355                                                                 let expr4_0 =
1356                                                                     Amode::ImmRegRegShift {
1357                                                                         simm32: pattern1_0,
1358                                                                         base: expr0_0,
1359                                                                         index: expr3_0,
1360                                                                         shift: pattern16_0,
1361                                                                         flags: pattern1_2,
1362                                                                     };
1363                                                                 return Some(expr4_0);
1364                                                             }
1365                                                         }
1366                                                     }
1367                                                 }
1368                                             }
1369                                         }
1370                                     }
1371                                 }
1372                             }
1373                         }
1374                     }
1375                 }
1376                 _ => {}
1377             }
1378         }
1379     }
1380     let pattern1_0 = arg1;
1381     if let Some(pattern2_0) = C::def_inst(ctx, pattern1_0) {
1382         let pattern3_0 = C::inst_data(ctx, pattern2_0);
1383         if let &InstructionData::Binary {
1384             opcode: ref pattern4_0,
1385             args: ref pattern4_1,
1386         } = &pattern3_0
1387         {
1388             if let &Opcode::Iadd = pattern4_0 {
1389                 let (pattern6_0, pattern6_1) = C::unpack_value_array_2(ctx, pattern4_1);
1390                 // Rule at src/isa/x64/inst.isle line 889.
1391                 let expr0_0 = constructor_amode_add(ctx, pattern0_0, pattern6_0)?;
1392                 let expr1_0 = constructor_amode_add(ctx, &expr0_0, pattern6_1)?;
1393                 return Some(expr1_0);
1394             }
1395         }
1396     }
1397     let pattern0_0 = arg0;
1398     match pattern0_0 {
1399         &Amode::ImmReg {
1400             simm32: pattern1_0,
1401             base: pattern1_1,
1402             flags: pattern1_2,
1403         } => {
1404             if let Some(()) = C::invalid_reg_etor(ctx, pattern1_1) {
1405                 let pattern3_0 = arg1;
1406                 // Rule at src/isa/x64/inst.isle line 898.
1407                 let expr0_0 = C::put_in_reg(ctx, pattern3_0);
1408                 let expr1_0 = Amode::ImmReg {
1409                     simm32: pattern1_0,
1410                     base: expr0_0,
1411                     flags: pattern1_2,
1412                 };
1413                 return Some(expr1_0);
1414             }
1415             let pattern2_0 = arg1;
1416             let mut closure3 = || {
1417                 return Some(pattern1_1);
1418             };
1419             if let Some(pattern3_0) = closure3() {
1420                 if let Some(()) = C::valid_reg(ctx, pattern3_0) {
1421                     // Rule at src/isa/x64/inst.isle line 904.
1422                     let expr0_0 = C::gpr_new(ctx, pattern1_1);
1423                     let expr1_0 = constructor_put_in_gpr(ctx, pattern2_0)?;
1424                     let expr2_0: u8 = 0;
1425                     let expr3_0 = Amode::ImmRegRegShift {
1426                         simm32: pattern1_0,
1427                         base: expr0_0,
1428                         index: expr1_0,
1429                         shift: expr2_0,
1430                         flags: pattern1_2,
1431                     };
1432                     return Some(expr3_0);
1433                 }
1434             }
1435         }
1436         &Amode::ImmRegRegShift {
1437             simm32: pattern1_0,
1438             base: pattern1_1,
1439             index: pattern1_2,
1440             shift: pattern1_3,
1441             flags: pattern1_4,
1442         } => {
1443             let pattern2_0 = arg1;
1444             // Rule at src/isa/x64/inst.isle line 980.
1445             let expr0_0: Type = I64;
1446             let expr1_0 = constructor_put_in_gpr_mem_imm(ctx, pattern2_0)?;
1447             let expr2_0 = constructor_x64_add(ctx, expr0_0, pattern1_1, &expr1_0)?;
1448             let expr3_0 = Amode::ImmRegRegShift {
1449                 simm32: pattern1_0,
1450                 base: expr2_0,
1451                 index: pattern1_2,
1452                 shift: pattern1_3,
1453                 flags: pattern1_4,
1454             };
1455             return Some(expr3_0);
1456         }
1457         _ => {}
1458     }
1459     return None;
1460 }
1461 
1462 // Generated as internal constructor for term reg_to_gpr_mem_imm.
1463 pub fn constructor_reg_to_gpr_mem_imm<C: Context>(ctx: &mut C, arg0: Reg) -> Option<GprMemImm> {
1464     let pattern0_0 = arg0;
1465     // Rule at src/isa/x64/inst.isle line 1184.
1466     let expr0_0 = C::gpr_new(ctx, pattern0_0);
1467     let expr1_0 = C::gpr_to_gpr_mem_imm(ctx, expr0_0);
1468     return Some(expr1_0);
1469 }
1470 
1471 // Generated as internal constructor for term put_in_gpr.
1472 pub fn constructor_put_in_gpr<C: Context>(ctx: &mut C, arg0: Value) -> Option<Gpr> {
1473     let pattern0_0 = arg0;
1474     // Rule at src/isa/x64/inst.isle line 1191.
1475     let expr0_0 = C::put_in_reg(ctx, pattern0_0);
1476     let expr1_0 = C::gpr_new(ctx, expr0_0);
1477     return Some(expr1_0);
1478 }
1479 
1480 // Generated as internal constructor for term put_in_gpr_mem.
1481 pub fn constructor_put_in_gpr_mem<C: Context>(ctx: &mut C, arg0: Value) -> Option<GprMem> {
1482     let pattern0_0 = arg0;
1483     // Rule at src/isa/x64/inst.isle line 1198.
1484     let expr0_0 = C::put_in_reg_mem(ctx, pattern0_0);
1485     let expr1_0 = C::reg_mem_to_gpr_mem(ctx, &expr0_0);
1486     return Some(expr1_0);
1487 }
1488 
1489 // Generated as internal constructor for term put_in_gpr_mem_imm.
1490 pub fn constructor_put_in_gpr_mem_imm<C: Context>(ctx: &mut C, arg0: Value) -> Option<GprMemImm> {
1491     let pattern0_0 = arg0;
1492     // Rule at src/isa/x64/inst.isle line 1205.
1493     let expr0_0 = C::put_in_reg_mem_imm(ctx, pattern0_0);
1494     let expr1_0 = C::gpr_mem_imm_new(ctx, &expr0_0);
1495     return Some(expr1_0);
1496 }
1497 
1498 // Generated as internal constructor for term put_in_xmm.
1499 pub fn constructor_put_in_xmm<C: Context>(ctx: &mut C, arg0: Value) -> Option<Xmm> {
1500     let pattern0_0 = arg0;
1501     // Rule at src/isa/x64/inst.isle line 1212.
1502     let expr0_0 = C::put_in_reg(ctx, pattern0_0);
1503     let expr1_0 = C::xmm_new(ctx, expr0_0);
1504     return Some(expr1_0);
1505 }
1506 
1507 // Generated as internal constructor for term put_in_xmm_mem.
1508 pub fn constructor_put_in_xmm_mem<C: Context>(ctx: &mut C, arg0: Value) -> Option<XmmMem> {
1509     let pattern0_0 = arg0;
1510     // Rule at src/isa/x64/inst.isle line 1219.
1511     let expr0_0 = C::put_in_reg_mem(ctx, pattern0_0);
1512     let expr1_0 = C::reg_mem_to_xmm_mem(ctx, &expr0_0);
1513     return Some(expr1_0);
1514 }
1515 
1516 // Generated as internal constructor for term put_in_xmm_mem_imm.
1517 pub fn constructor_put_in_xmm_mem_imm<C: Context>(ctx: &mut C, arg0: Value) -> Option<XmmMemImm> {
1518     let pattern0_0 = arg0;
1519     // Rule at src/isa/x64/inst.isle line 1226.
1520     let expr0_0 = C::put_in_reg_mem_imm(ctx, pattern0_0);
1521     let expr1_0 = C::xmm_mem_imm_new(ctx, &expr0_0);
1522     return Some(expr1_0);
1523 }
1524 
1525 // Generated as internal constructor for term output_gpr.
1526 pub fn constructor_output_gpr<C: Context>(ctx: &mut C, arg0: Gpr) -> Option<InstOutput> {
1527     let pattern0_0 = arg0;
1528     // Rule at src/isa/x64/inst.isle line 1231.
1529     let expr0_0 = C::gpr_to_reg(ctx, pattern0_0);
1530     let expr1_0 = constructor_output_reg(ctx, expr0_0)?;
1531     return Some(expr1_0);
1532 }
1533 
1534 // Generated as internal constructor for term value_gprs.
1535 pub fn constructor_value_gprs<C: Context>(ctx: &mut C, arg0: Gpr, arg1: Gpr) -> Option<ValueRegs> {
1536     let pattern0_0 = arg0;
1537     let pattern1_0 = arg1;
1538     // Rule at src/isa/x64/inst.isle line 1236.
1539     let expr0_0 = C::gpr_to_reg(ctx, pattern0_0);
1540     let expr1_0 = C::gpr_to_reg(ctx, pattern1_0);
1541     let expr2_0 = C::value_regs(ctx, expr0_0, expr1_0);
1542     return Some(expr2_0);
1543 }
1544 
1545 // Generated as internal constructor for term output_xmm.
1546 pub fn constructor_output_xmm<C: Context>(ctx: &mut C, arg0: Xmm) -> Option<InstOutput> {
1547     let pattern0_0 = arg0;
1548     // Rule at src/isa/x64/inst.isle line 1241.
1549     let expr0_0 = C::xmm_to_reg(ctx, pattern0_0);
1550     let expr1_0 = constructor_output_reg(ctx, expr0_0)?;
1551     return Some(expr1_0);
1552 }
1553 
1554 // Generated as internal constructor for term value_regs_get_gpr.
1555 pub fn constructor_value_regs_get_gpr<C: Context>(
1556     ctx: &mut C,
1557     arg0: ValueRegs,
1558     arg1: usize,
1559 ) -> Option<Gpr> {
1560     let pattern0_0 = arg0;
1561     let pattern1_0 = arg1;
1562     // Rule at src/isa/x64/inst.isle line 1248.
1563     let expr0_0 = C::value_regs_get(ctx, pattern0_0, pattern1_0);
1564     let expr1_0 = C::gpr_new(ctx, expr0_0);
1565     return Some(expr1_0);
1566 }
1567 
1568 // Generated as internal constructor for term lo_gpr.
1569 pub fn constructor_lo_gpr<C: Context>(ctx: &mut C, arg0: Value) -> Option<Gpr> {
1570     let pattern0_0 = arg0;
1571     // Rule at src/isa/x64/inst.isle line 1261.
1572     let expr0_0 = constructor_lo_reg(ctx, pattern0_0)?;
1573     let expr1_0 = C::gpr_new(ctx, expr0_0);
1574     return Some(expr1_0);
1575 }
1576 
1577 // Generated as internal constructor for term sink_load_to_gpr_mem_imm.
1578 pub fn constructor_sink_load_to_gpr_mem_imm<C: Context>(
1579     ctx: &mut C,
1580     arg0: &SinkableLoad,
1581 ) -> Option<GprMemImm> {
1582     let pattern0_0 = arg0;
1583     // Rule at src/isa/x64/inst.isle line 1344.
1584     let expr0_0 = C::sink_load(ctx, pattern0_0);
1585     let expr1_0 = C::gpr_mem_imm_new(ctx, &expr0_0);
1586     return Some(expr1_0);
1587 }
1588 
1589 // Generated as internal constructor for term extend_to_gpr.
1590 pub fn constructor_extend_to_gpr<C: Context>(
1591     ctx: &mut C,
1592     arg0: Value,
1593     arg1: Type,
1594     arg2: &ExtendKind,
1595 ) -> Option<Gpr> {
1596     let pattern0_0 = arg0;
1597     let pattern1_0 = C::value_type(ctx, pattern0_0);
1598     let pattern2_0 = arg1;
1599     if pattern2_0 == pattern1_0 {
1600         let pattern4_0 = arg2;
1601         // Rule at src/isa/x64/inst.isle line 1366.
1602         let expr0_0 = constructor_put_in_gpr(ctx, pattern0_0)?;
1603         return Some(expr0_0);
1604     }
1605     let pattern3_0 = arg2;
1606     // Rule at src/isa/x64/inst.isle line 1369.
1607     let expr0_0 = C::ty_bits_u16(ctx, pattern1_0);
1608     let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern2_0);
1609     let expr2_0 = constructor_operand_size_bits(ctx, &expr1_0)?;
1610     let expr3_0 = C::ext_mode(ctx, expr0_0, expr2_0);
1611     let expr4_0 = constructor_put_in_gpr_mem(ctx, pattern0_0)?;
1612     let expr5_0 = constructor_extend(ctx, pattern3_0, pattern2_0, &expr3_0, &expr4_0)?;
1613     return Some(expr5_0);
1614 }
1615 
1616 // Generated as internal constructor for term extend.
1617 pub fn constructor_extend<C: Context>(
1618     ctx: &mut C,
1619     arg0: &ExtendKind,
1620     arg1: Type,
1621     arg2: &ExtMode,
1622     arg3: &GprMem,
1623 ) -> Option<Gpr> {
1624     let pattern0_0 = arg0;
1625     match pattern0_0 {
1626         &ExtendKind::Sign => {
1627             let pattern2_0 = arg1;
1628             let pattern3_0 = arg2;
1629             let pattern4_0 = arg3;
1630             // Rule at src/isa/x64/inst.isle line 1389.
1631             let expr0_0 = constructor_x64_movsx(ctx, pattern3_0, pattern4_0)?;
1632             return Some(expr0_0);
1633         }
1634         &ExtendKind::Zero => {
1635             let pattern2_0 = arg1;
1636             let pattern3_0 = arg2;
1637             let pattern4_0 = arg3;
1638             // Rule at src/isa/x64/inst.isle line 1385.
1639             let expr0_0 = constructor_x64_movzx(ctx, pattern3_0, pattern4_0)?;
1640             return Some(expr0_0);
1641         }
1642         _ => {}
1643     }
1644     return None;
1645 }
1646 
1647 // Generated as internal constructor for term sse_xor_op.
1648 pub fn constructor_sse_xor_op<C: Context>(ctx: &mut C, arg0: Type) -> Option<SseOpcode> {
1649     let pattern0_0 = arg0;
1650     if pattern0_0 == F32X4 {
1651         // Rule at src/isa/x64/inst.isle line 1396.
1652         let expr0_0 = SseOpcode::Xorps;
1653         return Some(expr0_0);
1654     }
1655     if pattern0_0 == F64X2 {
1656         // Rule at src/isa/x64/inst.isle line 1397.
1657         let expr0_0 = SseOpcode::Xorpd;
1658         return Some(expr0_0);
1659     }
1660     if let Some((pattern1_0, pattern1_1)) = C::multi_lane(ctx, pattern0_0) {
1661         // Rule at src/isa/x64/inst.isle line 1398.
1662         let expr0_0 = SseOpcode::Pxor;
1663         return Some(expr0_0);
1664     }
1665     return None;
1666 }
1667 
1668 // Generated as internal constructor for term sse_xor.
1669 pub fn constructor_sse_xor<C: Context>(
1670     ctx: &mut C,
1671     arg0: Type,
1672     arg1: Xmm,
1673     arg2: &XmmMem,
1674 ) -> Option<Xmm> {
1675     let pattern0_0 = arg0;
1676     let pattern1_0 = arg1;
1677     let pattern2_0 = arg2;
1678     // Rule at src/isa/x64/inst.isle line 1402.
1679     let expr0_0 = constructor_sse_xor_op(ctx, pattern0_0)?;
1680     let expr1_0 = constructor_xmm_rm_r(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?;
1681     return Some(expr1_0);
1682 }
1683 
1684 // Generated as internal constructor for term sse_cmp_op.
1685 pub fn constructor_sse_cmp_op<C: Context>(ctx: &mut C, arg0: Type) -> Option<SseOpcode> {
1686     let pattern0_0 = arg0;
1687     if pattern0_0 == F32X4 {
1688         // Rule at src/isa/x64/inst.isle line 1411.
1689         let expr0_0 = SseOpcode::Cmpps;
1690         return Some(expr0_0);
1691     }
1692     if pattern0_0 == F64X2 {
1693         // Rule at src/isa/x64/inst.isle line 1412.
1694         let expr0_0 = SseOpcode::Cmppd;
1695         return Some(expr0_0);
1696     }
1697     if let Some((pattern1_0, pattern1_1)) = C::multi_lane(ctx, pattern0_0) {
1698         if pattern1_0 == 8 {
1699             if pattern1_1 == 16 {
1700                 // Rule at src/isa/x64/inst.isle line 1407.
1701                 let expr0_0 = SseOpcode::Pcmpeqb;
1702                 return Some(expr0_0);
1703             }
1704         }
1705         if pattern1_0 == 16 {
1706             if pattern1_1 == 8 {
1707                 // Rule at src/isa/x64/inst.isle line 1408.
1708                 let expr0_0 = SseOpcode::Pcmpeqw;
1709                 return Some(expr0_0);
1710             }
1711         }
1712         if pattern1_0 == 32 {
1713             if pattern1_1 == 4 {
1714                 // Rule at src/isa/x64/inst.isle line 1409.
1715                 let expr0_0 = SseOpcode::Pcmpeqd;
1716                 return Some(expr0_0);
1717             }
1718         }
1719         if pattern1_0 == 64 {
1720             if pattern1_1 == 2 {
1721                 // Rule at src/isa/x64/inst.isle line 1410.
1722                 let expr0_0 = SseOpcode::Pcmpeqq;
1723                 return Some(expr0_0);
1724             }
1725         }
1726     }
1727     return None;
1728 }
1729 
1730 // Generated as internal constructor for term vector_all_ones.
1731 pub fn constructor_vector_all_ones<C: Context>(ctx: &mut C, arg0: Type) -> Option<Xmm> {
1732     let pattern0_0 = arg0;
1733     // Rule at src/isa/x64/inst.isle line 1426.
1734     let expr0_0 = C::temp_writable_xmm(ctx);
1735     let expr1_0: Type = I32X4;
1736     let expr2_0 = constructor_sse_cmp_op(ctx, expr1_0)?;
1737     let expr3_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
1738     let expr4_0 = constructor_writable_xmm_to_xmm_mem(ctx, expr0_0)?;
1739     let expr5_0 = MInst::XmmRmR {
1740         op: expr2_0,
1741         src1: expr3_0,
1742         src2: expr4_0,
1743         dst: expr0_0,
1744     };
1745     let expr6_0 = C::emit(ctx, &expr5_0);
1746     let expr7_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
1747     return Some(expr7_0);
1748 }
1749 
1750 // Generated as internal constructor for term make_i64x2_from_lanes.
1751 pub fn constructor_make_i64x2_from_lanes<C: Context>(
1752     ctx: &mut C,
1753     arg0: &GprMem,
1754     arg1: &GprMem,
1755 ) -> Option<Xmm> {
1756     let pattern0_0 = arg0;
1757     let pattern1_0 = arg1;
1758     // Rule at src/isa/x64/inst.isle line 1436.
1759     let expr0_0 = C::temp_writable_xmm(ctx);
1760     let expr1_0 = C::writable_xmm_to_reg(ctx, expr0_0);
1761     let expr2_0 = MInst::XmmUninitializedValue { dst: expr0_0 };
1762     let expr3_0 = C::emit(ctx, &expr2_0);
1763     let expr4_0 = SseOpcode::Pinsrd;
1764     let expr5_0 = C::writable_reg_to_reg(ctx, expr1_0);
1765     let expr6_0 = C::gpr_mem_to_reg_mem(ctx, pattern0_0);
1766     let expr7_0: u8 = 0;
1767     let expr8_0 = OperandSize::Size64;
1768     let expr9_0 = MInst::XmmRmRImm {
1769         op: expr4_0,
1770         src1: expr5_0,
1771         src2: expr6_0,
1772         dst: expr1_0,
1773         imm: expr7_0,
1774         size: expr8_0,
1775     };
1776     let expr10_0 = C::emit(ctx, &expr9_0);
1777     let expr11_0 = SseOpcode::Pinsrd;
1778     let expr12_0 = C::writable_reg_to_reg(ctx, expr1_0);
1779     let expr13_0 = C::gpr_mem_to_reg_mem(ctx, pattern1_0);
1780     let expr14_0: u8 = 1;
1781     let expr15_0 = OperandSize::Size64;
1782     let expr16_0 = MInst::XmmRmRImm {
1783         op: expr11_0,
1784         src1: expr12_0,
1785         src2: expr13_0,
1786         dst: expr1_0,
1787         imm: expr14_0,
1788         size: expr15_0,
1789     };
1790     let expr17_0 = C::emit(ctx, &expr16_0);
1791     let expr18_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
1792     return Some(expr18_0);
1793 }
1794 
1795 // Generated as internal constructor for term mov_rmi_to_xmm.
1796 pub fn constructor_mov_rmi_to_xmm<C: Context>(ctx: &mut C, arg0: &RegMemImm) -> Option<XmmMemImm> {
1797     let pattern0_0 = arg0;
1798     match pattern0_0 {
1799         &RegMemImm::Imm { simm32: pattern1_0 } => {
1800             // Rule at src/isa/x64/inst.isle line 1457.
1801             let expr0_0 = C::xmm_mem_imm_new(ctx, pattern0_0);
1802             return Some(expr0_0);
1803         }
1804         &RegMemImm::Reg { reg: pattern1_0 } => {
1805             // Rule at src/isa/x64/inst.isle line 1458.
1806             let expr0_0 = SseOpcode::Movd;
1807             let expr1_0 = C::reg_to_gpr_mem(ctx, pattern1_0);
1808             let expr2_0 = OperandSize::Size32;
1809             let expr3_0 = constructor_gpr_to_xmm(ctx, &expr0_0, &expr1_0, &expr2_0)?;
1810             let expr4_0 = C::xmm_to_xmm_mem_imm(ctx, expr3_0);
1811             return Some(expr4_0);
1812         }
1813         &RegMemImm::Mem {
1814             addr: ref pattern1_0,
1815         } => {
1816             // Rule at src/isa/x64/inst.isle line 1456.
1817             let expr0_0 = C::xmm_mem_imm_new(ctx, pattern0_0);
1818             return Some(expr0_0);
1819         }
1820         _ => {}
1821     }
1822     return None;
1823 }
1824 
1825 // Generated as internal constructor for term x64_load.
1826 pub fn constructor_x64_load<C: Context>(
1827     ctx: &mut C,
1828     arg0: Type,
1829     arg1: &SyntheticAmode,
1830     arg2: &ExtKind,
1831 ) -> Option<Reg> {
1832     let pattern0_0 = arg0;
1833     if pattern0_0 == I64 {
1834         let pattern2_0 = arg1;
1835         let pattern3_0 = arg2;
1836         // Rule at src/isa/x64/inst.isle line 1472.
1837         let expr0_0 = C::temp_writable_gpr(ctx);
1838         let expr1_0 = MInst::Mov64MR {
1839             src: pattern2_0.clone(),
1840             dst: expr0_0,
1841         };
1842         let expr2_0 = C::emit(ctx, &expr1_0);
1843         let expr3_0 = constructor_writable_gpr_to_r_reg(ctx, expr0_0)?;
1844         return Some(expr3_0);
1845     }
1846     if pattern0_0 == F32 {
1847         let pattern2_0 = arg1;
1848         let pattern3_0 = arg2;
1849         // Rule at src/isa/x64/inst.isle line 1477.
1850         let expr0_0 = SseOpcode::Movss;
1851         let expr1_0 = constructor_synthetic_amode_to_xmm_mem(ctx, pattern2_0)?;
1852         let expr2_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, &expr1_0)?;
1853         let expr3_0 = C::xmm_to_reg(ctx, expr2_0);
1854         return Some(expr3_0);
1855     }
1856     if pattern0_0 == F64 {
1857         let pattern2_0 = arg1;
1858         let pattern3_0 = arg2;
1859         // Rule at src/isa/x64/inst.isle line 1481.
1860         let expr0_0 = SseOpcode::Movsd;
1861         let expr1_0 = constructor_synthetic_amode_to_xmm_mem(ctx, pattern2_0)?;
1862         let expr2_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, &expr1_0)?;
1863         let expr3_0 = C::xmm_to_reg(ctx, expr2_0);
1864         return Some(expr3_0);
1865     }
1866     if pattern0_0 == F32X4 {
1867         let pattern2_0 = arg1;
1868         let pattern3_0 = arg2;
1869         // Rule at src/isa/x64/inst.isle line 1485.
1870         let expr0_0 = SseOpcode::Movups;
1871         let expr1_0 = constructor_synthetic_amode_to_xmm_mem(ctx, pattern2_0)?;
1872         let expr2_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, &expr1_0)?;
1873         let expr3_0 = C::xmm_to_reg(ctx, expr2_0);
1874         return Some(expr3_0);
1875     }
1876     if pattern0_0 == F64X2 {
1877         let pattern2_0 = arg1;
1878         let pattern3_0 = arg2;
1879         // Rule at src/isa/x64/inst.isle line 1489.
1880         let expr0_0 = SseOpcode::Movupd;
1881         let expr1_0 = constructor_synthetic_amode_to_xmm_mem(ctx, pattern2_0)?;
1882         let expr2_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, &expr1_0)?;
1883         let expr3_0 = C::xmm_to_reg(ctx, expr2_0);
1884         return Some(expr3_0);
1885     }
1886     if let Some((pattern1_0, pattern1_1)) = C::multi_lane(ctx, pattern0_0) {
1887         let pattern2_0 = arg1;
1888         let pattern3_0 = arg2;
1889         // Rule at src/isa/x64/inst.isle line 1493.
1890         let expr0_0 = SseOpcode::Movdqu;
1891         let expr1_0 = constructor_synthetic_amode_to_xmm_mem(ctx, pattern2_0)?;
1892         let expr2_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, &expr1_0)?;
1893         let expr3_0 = C::xmm_to_reg(ctx, expr2_0);
1894         return Some(expr3_0);
1895     }
1896     if let Some(pattern1_0) = C::fits_in_32(ctx, pattern0_0) {
1897         let pattern2_0 = arg1;
1898         let pattern3_0 = arg2;
1899         if let &ExtKind::SignExtend = pattern3_0 {
1900             // Rule at src/isa/x64/inst.isle line 1468.
1901             let expr0_0 = C::ty_bytes(ctx, pattern1_0);
1902             let expr1_0: u16 = 8;
1903             let expr2_0 = C::ext_mode(ctx, expr0_0, expr1_0);
1904             let expr3_0 = constructor_synthetic_amode_to_gpr_mem(ctx, pattern2_0)?;
1905             let expr4_0 = constructor_x64_movsx(ctx, &expr2_0, &expr3_0)?;
1906             let expr5_0 = C::gpr_to_reg(ctx, expr4_0);
1907             return Some(expr5_0);
1908         }
1909     }
1910     return None;
1911 }
1912 
1913 // Generated as internal constructor for term x64_mov.
1914 pub fn constructor_x64_mov<C: Context>(ctx: &mut C, arg0: &Amode) -> Option<Reg> {
1915     let pattern0_0 = arg0;
1916     // Rule at src/isa/x64/inst.isle line 1498.
1917     let expr0_0 = C::temp_writable_gpr(ctx);
1918     let expr1_0 = C::amode_to_synthetic_amode(ctx, pattern0_0);
1919     let expr2_0 = MInst::Mov64MR {
1920         src: expr1_0,
1921         dst: expr0_0,
1922     };
1923     let expr3_0 = C::emit(ctx, &expr2_0);
1924     let expr4_0 = constructor_writable_gpr_to_r_reg(ctx, expr0_0)?;
1925     return Some(expr4_0);
1926 }
1927 
1928 // Generated as internal constructor for term x64_movzx.
1929 pub fn constructor_x64_movzx<C: Context>(
1930     ctx: &mut C,
1931     arg0: &ExtMode,
1932     arg1: &GprMem,
1933 ) -> Option<Gpr> {
1934     let pattern0_0 = arg0;
1935     let pattern1_0 = arg1;
1936     // Rule at src/isa/x64/inst.isle line 1504.
1937     let expr0_0 = C::temp_writable_gpr(ctx);
1938     let expr1_0 = MInst::MovzxRmR {
1939         ext_mode: pattern0_0.clone(),
1940         src: pattern1_0.clone(),
1941         dst: expr0_0,
1942     };
1943     let expr2_0 = C::emit(ctx, &expr1_0);
1944     let expr3_0 = C::writable_gpr_to_gpr(ctx, expr0_0);
1945     return Some(expr3_0);
1946 }
1947 
1948 // Generated as internal constructor for term x64_movsx.
1949 pub fn constructor_x64_movsx<C: Context>(
1950     ctx: &mut C,
1951     arg0: &ExtMode,
1952     arg1: &GprMem,
1953 ) -> Option<Gpr> {
1954     let pattern0_0 = arg0;
1955     let pattern1_0 = arg1;
1956     // Rule at src/isa/x64/inst.isle line 1510.
1957     let expr0_0 = C::temp_writable_gpr(ctx);
1958     let expr1_0 = MInst::MovsxRmR {
1959         ext_mode: pattern0_0.clone(),
1960         src: pattern1_0.clone(),
1961         dst: expr0_0,
1962     };
1963     let expr2_0 = C::emit(ctx, &expr1_0);
1964     let expr3_0 = C::writable_gpr_to_gpr(ctx, expr0_0);
1965     return Some(expr3_0);
1966 }
1967 
1968 // Generated as internal constructor for term x64_movss_load.
1969 pub fn constructor_x64_movss_load<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Option<Xmm> {
1970     let pattern0_0 = arg0;
1971     // Rule at src/isa/x64/inst.isle line 1516.
1972     let expr0_0 = SseOpcode::Movss;
1973     let expr1_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, pattern0_0)?;
1974     return Some(expr1_0);
1975 }
1976 
1977 // Generated as internal constructor for term x64_movsd_load.
1978 pub fn constructor_x64_movsd_load<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Option<Xmm> {
1979     let pattern0_0 = arg0;
1980     // Rule at src/isa/x64/inst.isle line 1520.
1981     let expr0_0 = SseOpcode::Movsd;
1982     let expr1_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, pattern0_0)?;
1983     return Some(expr1_0);
1984 }
1985 
1986 // Generated as internal constructor for term x64_movups.
1987 pub fn constructor_x64_movups<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Option<Xmm> {
1988     let pattern0_0 = arg0;
1989     // Rule at src/isa/x64/inst.isle line 1524.
1990     let expr0_0 = SseOpcode::Movups;
1991     let expr1_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, pattern0_0)?;
1992     return Some(expr1_0);
1993 }
1994 
1995 // Generated as internal constructor for term x64_movupd.
1996 pub fn constructor_x64_movupd<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Option<Xmm> {
1997     let pattern0_0 = arg0;
1998     // Rule at src/isa/x64/inst.isle line 1528.
1999     let expr0_0 = SseOpcode::Movupd;
2000     let expr1_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, pattern0_0)?;
2001     return Some(expr1_0);
2002 }
2003 
2004 // Generated as internal constructor for term x64_movdqu.
2005 pub fn constructor_x64_movdqu<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Option<Xmm> {
2006     let pattern0_0 = arg0;
2007     // Rule at src/isa/x64/inst.isle line 1532.
2008     let expr0_0 = SseOpcode::Movdqu;
2009     let expr1_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, pattern0_0)?;
2010     return Some(expr1_0);
2011 }
2012 
2013 // Generated as internal constructor for term x64_pmovsxbw.
2014 pub fn constructor_x64_pmovsxbw<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Option<Xmm> {
2015     let pattern0_0 = arg0;
2016     // Rule at src/isa/x64/inst.isle line 1536.
2017     let expr0_0 = SseOpcode::Pmovsxbw;
2018     let expr1_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, pattern0_0)?;
2019     return Some(expr1_0);
2020 }
2021 
2022 // Generated as internal constructor for term x64_pmovzxbw.
2023 pub fn constructor_x64_pmovzxbw<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Option<Xmm> {
2024     let pattern0_0 = arg0;
2025     // Rule at src/isa/x64/inst.isle line 1540.
2026     let expr0_0 = SseOpcode::Pmovzxbw;
2027     let expr1_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, pattern0_0)?;
2028     return Some(expr1_0);
2029 }
2030 
2031 // Generated as internal constructor for term x64_pmovsxwd.
2032 pub fn constructor_x64_pmovsxwd<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Option<Xmm> {
2033     let pattern0_0 = arg0;
2034     // Rule at src/isa/x64/inst.isle line 1544.
2035     let expr0_0 = SseOpcode::Pmovsxwd;
2036     let expr1_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, pattern0_0)?;
2037     return Some(expr1_0);
2038 }
2039 
2040 // Generated as internal constructor for term x64_pmovzxwd.
2041 pub fn constructor_x64_pmovzxwd<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Option<Xmm> {
2042     let pattern0_0 = arg0;
2043     // Rule at src/isa/x64/inst.isle line 1548.
2044     let expr0_0 = SseOpcode::Pmovzxwd;
2045     let expr1_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, pattern0_0)?;
2046     return Some(expr1_0);
2047 }
2048 
2049 // Generated as internal constructor for term x64_pmovsxdq.
2050 pub fn constructor_x64_pmovsxdq<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Option<Xmm> {
2051     let pattern0_0 = arg0;
2052     // Rule at src/isa/x64/inst.isle line 1552.
2053     let expr0_0 = SseOpcode::Pmovsxdq;
2054     let expr1_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, pattern0_0)?;
2055     return Some(expr1_0);
2056 }
2057 
2058 // Generated as internal constructor for term x64_pmovzxdq.
2059 pub fn constructor_x64_pmovzxdq<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Option<Xmm> {
2060     let pattern0_0 = arg0;
2061     // Rule at src/isa/x64/inst.isle line 1556.
2062     let expr0_0 = SseOpcode::Pmovzxdq;
2063     let expr1_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, pattern0_0)?;
2064     return Some(expr1_0);
2065 }
2066 
2067 // Generated as internal constructor for term x64_movrm.
2068 pub fn constructor_x64_movrm<C: Context>(
2069     ctx: &mut C,
2070     arg0: Type,
2071     arg1: &SyntheticAmode,
2072     arg2: Gpr,
2073 ) -> Option<SideEffectNoResult> {
2074     let pattern0_0 = arg0;
2075     let pattern1_0 = arg1;
2076     let pattern2_0 = arg2;
2077     // Rule at src/isa/x64/inst.isle line 1560.
2078     let expr0_0 = C::raw_operand_size_of_type(ctx, pattern0_0);
2079     let expr1_0 = MInst::MovRM {
2080         size: expr0_0,
2081         src: pattern2_0,
2082         dst: pattern1_0.clone(),
2083     };
2084     let expr2_0 = SideEffectNoResult::Inst { inst: expr1_0 };
2085     return Some(expr2_0);
2086 }
2087 
2088 // Generated as internal constructor for term x64_xmm_movrm.
2089 pub fn constructor_x64_xmm_movrm<C: Context>(
2090     ctx: &mut C,
2091     arg0: &SseOpcode,
2092     arg1: &SyntheticAmode,
2093     arg2: Xmm,
2094 ) -> Option<SideEffectNoResult> {
2095     let pattern0_0 = arg0;
2096     let pattern1_0 = arg1;
2097     let pattern2_0 = arg2;
2098     // Rule at src/isa/x64/inst.isle line 1565.
2099     let expr0_0 = C::xmm_to_reg(ctx, pattern2_0);
2100     let expr1_0 = MInst::XmmMovRM {
2101         op: pattern0_0.clone(),
2102         src: expr0_0,
2103         dst: pattern1_0.clone(),
2104     };
2105     let expr2_0 = SideEffectNoResult::Inst { inst: expr1_0 };
2106     return Some(expr2_0);
2107 }
2108 
2109 // Generated as internal constructor for term x64_xmm_load_const.
2110 pub fn constructor_x64_xmm_load_const<C: Context>(
2111     ctx: &mut C,
2112     arg0: Type,
2113     arg1: VCodeConstant,
2114 ) -> Option<Xmm> {
2115     let pattern0_0 = arg0;
2116     let pattern1_0 = arg1;
2117     // Rule at src/isa/x64/inst.isle line 1570.
2118     let expr0_0 = C::temp_writable_xmm(ctx);
2119     let expr1_0 = C::writable_xmm_to_reg(ctx, expr0_0);
2120     let expr2_0 = MInst::XmmLoadConst {
2121         src: pattern1_0,
2122         dst: expr1_0,
2123         ty: pattern0_0,
2124     };
2125     let expr3_0 = C::emit(ctx, &expr2_0);
2126     let expr4_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
2127     return Some(expr4_0);
2128 }
2129 
2130 // Generated as internal constructor for term alu_rmi_r.
2131 pub fn constructor_alu_rmi_r<C: Context>(
2132     ctx: &mut C,
2133     arg0: Type,
2134     arg1: &AluRmiROpcode,
2135     arg2: Gpr,
2136     arg3: &GprMemImm,
2137 ) -> Option<Gpr> {
2138     let pattern0_0 = arg0;
2139     let pattern1_0 = arg1;
2140     let pattern2_0 = arg2;
2141     let pattern3_0 = arg3;
2142     // Rule at src/isa/x64/inst.isle line 1583.
2143     let expr0_0 = C::temp_writable_gpr(ctx);
2144     let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
2145     let expr2_0 = MInst::AluRmiR {
2146         size: expr1_0,
2147         op: pattern1_0.clone(),
2148         src1: pattern2_0,
2149         src2: pattern3_0.clone(),
2150         dst: expr0_0,
2151     };
2152     let expr3_0 = C::emit(ctx, &expr2_0);
2153     let expr4_0 = C::writable_gpr_to_gpr(ctx, expr0_0);
2154     return Some(expr4_0);
2155 }
2156 
2157 // Generated as internal constructor for term x64_add.
2158 pub fn constructor_x64_add<C: Context>(
2159     ctx: &mut C,
2160     arg0: Type,
2161     arg1: Gpr,
2162     arg2: &GprMemImm,
2163 ) -> Option<Gpr> {
2164     let pattern0_0 = arg0;
2165     let pattern1_0 = arg1;
2166     let pattern2_0 = arg2;
2167     // Rule at src/isa/x64/inst.isle line 1591.
2168     let expr0_0 = AluRmiROpcode::Add;
2169     let expr1_0 = constructor_alu_rmi_r(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?;
2170     return Some(expr1_0);
2171 }
2172 
2173 // Generated as internal constructor for term x64_add_with_flags_paired.
2174 pub fn constructor_x64_add_with_flags_paired<C: Context>(
2175     ctx: &mut C,
2176     arg0: Type,
2177     arg1: Gpr,
2178     arg2: &GprMemImm,
2179 ) -> Option<ProducesFlags> {
2180     let pattern0_0 = arg0;
2181     let pattern1_0 = arg1;
2182     let pattern2_0 = arg2;
2183     // Rule at src/isa/x64/inst.isle line 1599.
2184     let expr0_0 = C::temp_writable_gpr(ctx);
2185     let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
2186     let expr2_0 = AluRmiROpcode::Add;
2187     let expr3_0 = MInst::AluRmiR {
2188         size: expr1_0,
2189         op: expr2_0,
2190         src1: pattern1_0,
2191         src2: pattern2_0.clone(),
2192         dst: expr0_0,
2193     };
2194     let expr4_0 = constructor_writable_gpr_to_r_reg(ctx, expr0_0)?;
2195     let expr5_0 = ProducesFlags::ProducesFlagsReturnsResultWithConsumer {
2196         inst: expr3_0,
2197         result: expr4_0,
2198     };
2199     return Some(expr5_0);
2200 }
2201 
2202 // Generated as internal constructor for term x64_adc_paired.
2203 pub fn constructor_x64_adc_paired<C: Context>(
2204     ctx: &mut C,
2205     arg0: Type,
2206     arg1: Gpr,
2207     arg2: &GprMemImm,
2208 ) -> Option<ConsumesFlags> {
2209     let pattern0_0 = arg0;
2210     let pattern1_0 = arg1;
2211     let pattern2_0 = arg2;
2212     // Rule at src/isa/x64/inst.isle line 1611.
2213     let expr0_0 = C::temp_writable_gpr(ctx);
2214     let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
2215     let expr2_0 = AluRmiROpcode::Adc;
2216     let expr3_0 = MInst::AluRmiR {
2217         size: expr1_0,
2218         op: expr2_0,
2219         src1: pattern1_0,
2220         src2: pattern2_0.clone(),
2221         dst: expr0_0,
2222     };
2223     let expr4_0 = constructor_writable_gpr_to_r_reg(ctx, expr0_0)?;
2224     let expr5_0 = ConsumesFlags::ConsumesFlagsReturnsResultWithProducer {
2225         inst: expr3_0,
2226         result: expr4_0,
2227     };
2228     return Some(expr5_0);
2229 }
2230 
2231 // Generated as internal constructor for term x64_sub.
2232 pub fn constructor_x64_sub<C: Context>(
2233     ctx: &mut C,
2234     arg0: Type,
2235     arg1: Gpr,
2236     arg2: &GprMemImm,
2237 ) -> Option<Gpr> {
2238     let pattern0_0 = arg0;
2239     let pattern1_0 = arg1;
2240     let pattern2_0 = arg2;
2241     // Rule at src/isa/x64/inst.isle line 1623.
2242     let expr0_0 = AluRmiROpcode::Sub;
2243     let expr1_0 = constructor_alu_rmi_r(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?;
2244     return Some(expr1_0);
2245 }
2246 
2247 // Generated as internal constructor for term x64_sub_with_flags_paired.
2248 pub fn constructor_x64_sub_with_flags_paired<C: Context>(
2249     ctx: &mut C,
2250     arg0: Type,
2251     arg1: Gpr,
2252     arg2: &GprMemImm,
2253 ) -> Option<ProducesFlags> {
2254     let pattern0_0 = arg0;
2255     let pattern1_0 = arg1;
2256     let pattern2_0 = arg2;
2257     // Rule at src/isa/x64/inst.isle line 1631.
2258     let expr0_0 = C::temp_writable_gpr(ctx);
2259     let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
2260     let expr2_0 = AluRmiROpcode::Sub;
2261     let expr3_0 = MInst::AluRmiR {
2262         size: expr1_0,
2263         op: expr2_0,
2264         src1: pattern1_0,
2265         src2: pattern2_0.clone(),
2266         dst: expr0_0,
2267     };
2268     let expr4_0 = constructor_writable_gpr_to_r_reg(ctx, expr0_0)?;
2269     let expr5_0 = ProducesFlags::ProducesFlagsReturnsResultWithConsumer {
2270         inst: expr3_0,
2271         result: expr4_0,
2272     };
2273     return Some(expr5_0);
2274 }
2275 
2276 // Generated as internal constructor for term x64_sbb_paired.
2277 pub fn constructor_x64_sbb_paired<C: Context>(
2278     ctx: &mut C,
2279     arg0: Type,
2280     arg1: Gpr,
2281     arg2: &GprMemImm,
2282 ) -> Option<ConsumesFlags> {
2283     let pattern0_0 = arg0;
2284     let pattern1_0 = arg1;
2285     let pattern2_0 = arg2;
2286     // Rule at src/isa/x64/inst.isle line 1643.
2287     let expr0_0 = C::temp_writable_gpr(ctx);
2288     let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
2289     let expr2_0 = AluRmiROpcode::Sbb;
2290     let expr3_0 = MInst::AluRmiR {
2291         size: expr1_0,
2292         op: expr2_0,
2293         src1: pattern1_0,
2294         src2: pattern2_0.clone(),
2295         dst: expr0_0,
2296     };
2297     let expr4_0 = constructor_writable_gpr_to_r_reg(ctx, expr0_0)?;
2298     let expr5_0 = ConsumesFlags::ConsumesFlagsReturnsResultWithProducer {
2299         inst: expr3_0,
2300         result: expr4_0,
2301     };
2302     return Some(expr5_0);
2303 }
2304 
2305 // Generated as internal constructor for term x64_mul.
2306 pub fn constructor_x64_mul<C: Context>(
2307     ctx: &mut C,
2308     arg0: Type,
2309     arg1: Gpr,
2310     arg2: &GprMemImm,
2311 ) -> Option<Gpr> {
2312     let pattern0_0 = arg0;
2313     let pattern1_0 = arg1;
2314     let pattern2_0 = arg2;
2315     // Rule at src/isa/x64/inst.isle line 1655.
2316     let expr0_0 = AluRmiROpcode::Mul;
2317     let expr1_0 = constructor_alu_rmi_r(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?;
2318     return Some(expr1_0);
2319 }
2320 
2321 // Generated as internal constructor for term x64_and.
2322 pub fn constructor_x64_and<C: Context>(
2323     ctx: &mut C,
2324     arg0: Type,
2325     arg1: Gpr,
2326     arg2: &GprMemImm,
2327 ) -> Option<Gpr> {
2328     let pattern0_0 = arg0;
2329     let pattern1_0 = arg1;
2330     let pattern2_0 = arg2;
2331     // Rule at src/isa/x64/inst.isle line 1663.
2332     let expr0_0 = AluRmiROpcode::And;
2333     let expr1_0 = constructor_alu_rmi_r(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?;
2334     return Some(expr1_0);
2335 }
2336 
2337 // Generated as internal constructor for term x64_and_with_flags_paired.
2338 pub fn constructor_x64_and_with_flags_paired<C: Context>(
2339     ctx: &mut C,
2340     arg0: Type,
2341     arg1: Gpr,
2342     arg2: &GprMemImm,
2343 ) -> Option<ProducesFlags> {
2344     let pattern0_0 = arg0;
2345     let pattern1_0 = arg1;
2346     let pattern2_0 = arg2;
2347     // Rule at src/isa/x64/inst.isle line 1670.
2348     let expr0_0 = C::temp_writable_gpr(ctx);
2349     let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
2350     let expr2_0 = AluRmiROpcode::And;
2351     let expr3_0 = MInst::AluRmiR {
2352         size: expr1_0,
2353         op: expr2_0,
2354         src1: pattern1_0,
2355         src2: pattern2_0.clone(),
2356         dst: expr0_0,
2357     };
2358     let expr4_0 = ProducesFlags::ProducesFlagsSideEffect { inst: expr3_0 };
2359     return Some(expr4_0);
2360 }
2361 
2362 // Generated as internal constructor for term x64_or.
2363 pub fn constructor_x64_or<C: Context>(
2364     ctx: &mut C,
2365     arg0: Type,
2366     arg1: Gpr,
2367     arg2: &GprMemImm,
2368 ) -> Option<Gpr> {
2369     let pattern0_0 = arg0;
2370     let pattern1_0 = arg1;
2371     let pattern2_0 = arg2;
2372     // Rule at src/isa/x64/inst.isle line 1681.
2373     let expr0_0 = AluRmiROpcode::Or;
2374     let expr1_0 = constructor_alu_rmi_r(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?;
2375     return Some(expr1_0);
2376 }
2377 
2378 // Generated as internal constructor for term x64_xor.
2379 pub fn constructor_x64_xor<C: Context>(
2380     ctx: &mut C,
2381     arg0: Type,
2382     arg1: Gpr,
2383     arg2: &GprMemImm,
2384 ) -> Option<Gpr> {
2385     let pattern0_0 = arg0;
2386     let pattern1_0 = arg1;
2387     let pattern2_0 = arg2;
2388     // Rule at src/isa/x64/inst.isle line 1689.
2389     let expr0_0 = AluRmiROpcode::Xor;
2390     let expr1_0 = constructor_alu_rmi_r(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?;
2391     return Some(expr1_0);
2392 }
2393 
2394 // Generated as internal constructor for term imm.
2395 pub fn constructor_imm<C: Context>(ctx: &mut C, arg0: Type, arg1: u64) -> Option<Reg> {
2396     let pattern0_0 = arg0;
2397     if pattern0_0 == I64 {
2398         let pattern2_0 = arg1;
2399         if let Some(pattern3_0) = C::nonzero_u64_fits_in_u32(ctx, pattern2_0) {
2400             // Rule at src/isa/x64/inst.isle line 1729.
2401             let expr0_0 = C::temp_writable_gpr(ctx);
2402             let expr1_0 = OperandSize::Size32;
2403             let expr2_0 = MInst::Imm {
2404                 dst_size: expr1_0,
2405                 simm64: pattern3_0,
2406                 dst: expr0_0,
2407             };
2408             let expr3_0 = C::emit(ctx, &expr2_0);
2409             let expr4_0 = constructor_writable_gpr_to_r_reg(ctx, expr0_0)?;
2410             return Some(expr4_0);
2411         }
2412     }
2413     if pattern0_0 == F32 {
2414         let pattern2_0 = arg1;
2415         if pattern2_0 == 0 {
2416             // Rule at src/isa/x64/inst.isle line 1758.
2417             let expr0_0 = C::temp_writable_xmm(ctx);
2418             let expr1_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
2419             let expr2_0 = SseOpcode::Xorps;
2420             let expr3_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
2421             let expr4_0 = MInst::XmmRmR {
2422                 op: expr2_0,
2423                 src1: expr1_0,
2424                 src2: expr3_0,
2425                 dst: expr0_0,
2426             };
2427             let expr5_0 = C::emit(ctx, &expr4_0);
2428             let expr6_0 = C::xmm_to_reg(ctx, expr1_0);
2429             return Some(expr6_0);
2430         }
2431         // Rule at src/isa/x64/inst.isle line 1706.
2432         let expr0_0 = SseOpcode::Movd;
2433         let expr1_0: Type = I32;
2434         let expr2_0 = constructor_imm(ctx, expr1_0, pattern2_0)?;
2435         let expr3_0 = C::reg_to_gpr_mem(ctx, expr2_0);
2436         let expr4_0 = OperandSize::Size32;
2437         let expr5_0 = constructor_gpr_to_xmm(ctx, &expr0_0, &expr3_0, &expr4_0)?;
2438         let expr6_0 = C::xmm_to_reg(ctx, expr5_0);
2439         return Some(expr6_0);
2440     }
2441     if pattern0_0 == F64 {
2442         let pattern2_0 = arg1;
2443         if pattern2_0 == 0 {
2444             // Rule at src/isa/x64/inst.isle line 1770.
2445             let expr0_0 = C::temp_writable_xmm(ctx);
2446             let expr1_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
2447             let expr2_0 = SseOpcode::Xorpd;
2448             let expr3_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
2449             let expr4_0 = MInst::XmmRmR {
2450                 op: expr2_0,
2451                 src1: expr1_0,
2452                 src2: expr3_0,
2453                 dst: expr0_0,
2454             };
2455             let expr5_0 = C::emit(ctx, &expr4_0);
2456             let expr6_0 = C::xmm_to_reg(ctx, expr1_0);
2457             return Some(expr6_0);
2458         }
2459         // Rule at src/isa/x64/inst.isle line 1712.
2460         let expr0_0 = SseOpcode::Movq;
2461         let expr1_0: Type = I64;
2462         let expr2_0 = constructor_imm(ctx, expr1_0, pattern2_0)?;
2463         let expr3_0 = C::reg_to_gpr_mem(ctx, expr2_0);
2464         let expr4_0 = OperandSize::Size64;
2465         let expr5_0 = constructor_gpr_to_xmm(ctx, &expr0_0, &expr3_0, &expr4_0)?;
2466         let expr6_0 = C::xmm_to_reg(ctx, expr5_0);
2467         return Some(expr6_0);
2468     }
2469     if let Some((pattern1_0, pattern1_1)) = C::multi_lane(ctx, pattern0_0) {
2470         let pattern2_0 = arg1;
2471         if pattern2_0 == 0 {
2472             // Rule at src/isa/x64/inst.isle line 1748.
2473             let expr0_0 = C::temp_writable_xmm(ctx);
2474             let expr1_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
2475             let expr2_0 = constructor_sse_xor_op(ctx, pattern0_0)?;
2476             let expr3_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
2477             let expr4_0 = MInst::XmmRmR {
2478                 op: expr2_0,
2479                 src1: expr1_0,
2480                 src2: expr3_0,
2481                 dst: expr0_0,
2482             };
2483             let expr5_0 = C::emit(ctx, &expr4_0);
2484             let expr6_0 = C::xmm_to_reg(ctx, expr1_0);
2485             return Some(expr6_0);
2486         }
2487     }
2488     if let Some(pattern1_0) = C::fits_in_64(ctx, pattern0_0) {
2489         let pattern2_0 = arg1;
2490         if pattern2_0 == 0 {
2491             // Rule at src/isa/x64/inst.isle line 1735.
2492             let expr0_0 = C::temp_writable_gpr(ctx);
2493             let expr1_0 = C::writable_gpr_to_gpr(ctx, expr0_0);
2494             let expr2_0 = C::operand_size_of_type_32_64(ctx, pattern1_0);
2495             let expr3_0 = AluRmiROpcode::Xor;
2496             let expr4_0 = C::gpr_to_gpr_mem_imm(ctx, expr1_0);
2497             let expr5_0 = MInst::AluRmiR {
2498                 size: expr2_0,
2499                 op: expr3_0,
2500                 src1: expr1_0,
2501                 src2: expr4_0,
2502                 dst: expr0_0,
2503             };
2504             let expr6_0 = C::emit(ctx, &expr5_0);
2505             let expr7_0 = C::gpr_to_reg(ctx, expr1_0);
2506             return Some(expr7_0);
2507         }
2508         // Rule at src/isa/x64/inst.isle line 1699.
2509         let expr0_0 = C::temp_writable_gpr(ctx);
2510         let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern1_0);
2511         let expr2_0 = MInst::Imm {
2512             dst_size: expr1_0,
2513             simm64: pattern2_0,
2514             dst: expr0_0,
2515         };
2516         let expr3_0 = C::emit(ctx, &expr2_0);
2517         let expr4_0 = constructor_writable_gpr_to_r_reg(ctx, expr0_0)?;
2518         return Some(expr4_0);
2519     }
2520     return None;
2521 }
2522 
2523 // Generated as internal constructor for term imm_i64.
2524 pub fn constructor_imm_i64<C: Context>(ctx: &mut C, arg0: Type, arg1: i64) -> Option<Reg> {
2525     let pattern0_0 = arg0;
2526     let pattern1_0 = arg1;
2527     // Rule at src/isa/x64/inst.isle line 1721.
2528     let expr0_0 = C::i64_as_u64(ctx, pattern1_0)?;
2529     let expr1_0 = constructor_imm(ctx, pattern0_0, expr0_0)?;
2530     return Some(expr1_0);
2531 }
2532 
2533 // Generated as internal constructor for term shift_r.
2534 pub fn constructor_shift_r<C: Context>(
2535     ctx: &mut C,
2536     arg0: Type,
2537     arg1: &ShiftKind,
2538     arg2: Gpr,
2539     arg3: &Imm8Gpr,
2540 ) -> Option<Gpr> {
2541     let pattern0_0 = arg0;
2542     let pattern1_0 = arg1;
2543     let pattern2_0 = arg2;
2544     let pattern3_0 = arg3;
2545     // Rule at src/isa/x64/inst.isle line 1783.
2546     let expr0_0 = C::temp_writable_gpr(ctx);
2547     let expr1_0 = C::raw_operand_size_of_type(ctx, pattern0_0);
2548     let expr2_0 = MInst::ShiftR {
2549         size: expr1_0,
2550         kind: pattern1_0.clone(),
2551         src: pattern2_0,
2552         num_bits: pattern3_0.clone(),
2553         dst: expr0_0,
2554     };
2555     let expr3_0 = C::emit(ctx, &expr2_0);
2556     let expr4_0 = C::writable_gpr_to_gpr(ctx, expr0_0);
2557     return Some(expr4_0);
2558 }
2559 
2560 // Generated as internal constructor for term x64_rotl.
2561 pub fn constructor_x64_rotl<C: Context>(
2562     ctx: &mut C,
2563     arg0: Type,
2564     arg1: Gpr,
2565     arg2: &Imm8Gpr,
2566 ) -> Option<Gpr> {
2567     let pattern0_0 = arg0;
2568     let pattern1_0 = arg1;
2569     let pattern2_0 = arg2;
2570     // Rule at src/isa/x64/inst.isle line 1793.
2571     let expr0_0 = ShiftKind::RotateLeft;
2572     let expr1_0 = constructor_shift_r(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?;
2573     return Some(expr1_0);
2574 }
2575 
2576 // Generated as internal constructor for term x64_rotr.
2577 pub fn constructor_x64_rotr<C: Context>(
2578     ctx: &mut C,
2579     arg0: Type,
2580     arg1: Gpr,
2581     arg2: &Imm8Gpr,
2582 ) -> Option<Gpr> {
2583     let pattern0_0 = arg0;
2584     let pattern1_0 = arg1;
2585     let pattern2_0 = arg2;
2586     // Rule at src/isa/x64/inst.isle line 1798.
2587     let expr0_0 = ShiftKind::RotateRight;
2588     let expr1_0 = constructor_shift_r(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?;
2589     return Some(expr1_0);
2590 }
2591 
2592 // Generated as internal constructor for term x64_shl.
2593 pub fn constructor_x64_shl<C: Context>(
2594     ctx: &mut C,
2595     arg0: Type,
2596     arg1: Gpr,
2597     arg2: &Imm8Gpr,
2598 ) -> Option<Gpr> {
2599     let pattern0_0 = arg0;
2600     let pattern1_0 = arg1;
2601     let pattern2_0 = arg2;
2602     // Rule at src/isa/x64/inst.isle line 1803.
2603     let expr0_0 = ShiftKind::ShiftLeft;
2604     let expr1_0 = constructor_shift_r(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?;
2605     return Some(expr1_0);
2606 }
2607 
2608 // Generated as internal constructor for term x64_shr.
2609 pub fn constructor_x64_shr<C: Context>(
2610     ctx: &mut C,
2611     arg0: Type,
2612     arg1: Gpr,
2613     arg2: &Imm8Gpr,
2614 ) -> Option<Gpr> {
2615     let pattern0_0 = arg0;
2616     let pattern1_0 = arg1;
2617     let pattern2_0 = arg2;
2618     // Rule at src/isa/x64/inst.isle line 1808.
2619     let expr0_0 = ShiftKind::ShiftRightLogical;
2620     let expr1_0 = constructor_shift_r(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?;
2621     return Some(expr1_0);
2622 }
2623 
2624 // Generated as internal constructor for term x64_sar.
2625 pub fn constructor_x64_sar<C: Context>(
2626     ctx: &mut C,
2627     arg0: Type,
2628     arg1: Gpr,
2629     arg2: &Imm8Gpr,
2630 ) -> Option<Gpr> {
2631     let pattern0_0 = arg0;
2632     let pattern1_0 = arg1;
2633     let pattern2_0 = arg2;
2634     // Rule at src/isa/x64/inst.isle line 1813.
2635     let expr0_0 = ShiftKind::ShiftRightArithmetic;
2636     let expr1_0 = constructor_shift_r(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?;
2637     return Some(expr1_0);
2638 }
2639 
2640 // Generated as internal constructor for term cmp_rmi_r.
2641 pub fn constructor_cmp_rmi_r<C: Context>(
2642     ctx: &mut C,
2643     arg0: &OperandSize,
2644     arg1: &CmpOpcode,
2645     arg2: &GprMemImm,
2646     arg3: Gpr,
2647 ) -> Option<ProducesFlags> {
2648     let pattern0_0 = arg0;
2649     let pattern1_0 = arg1;
2650     let pattern2_0 = arg2;
2651     let pattern3_0 = arg3;
2652     // Rule at src/isa/x64/inst.isle line 1818.
2653     let expr0_0 = MInst::CmpRmiR {
2654         size: pattern0_0.clone(),
2655         opcode: pattern1_0.clone(),
2656         src: pattern2_0.clone(),
2657         dst: pattern3_0,
2658     };
2659     let expr1_0 = ProducesFlags::ProducesFlagsSideEffect { inst: expr0_0 };
2660     return Some(expr1_0);
2661 }
2662 
2663 // Generated as internal constructor for term x64_cmp.
2664 pub fn constructor_x64_cmp<C: Context>(
2665     ctx: &mut C,
2666     arg0: &OperandSize,
2667     arg1: &GprMemImm,
2668     arg2: Gpr,
2669 ) -> Option<ProducesFlags> {
2670     let pattern0_0 = arg0;
2671     let pattern1_0 = arg1;
2672     let pattern2_0 = arg2;
2673     // Rule at src/isa/x64/inst.isle line 1827.
2674     let expr0_0 = CmpOpcode::Cmp;
2675     let expr1_0 = constructor_cmp_rmi_r(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?;
2676     return Some(expr1_0);
2677 }
2678 
2679 // Generated as internal constructor for term x64_cmp_imm.
2680 pub fn constructor_x64_cmp_imm<C: Context>(
2681     ctx: &mut C,
2682     arg0: &OperandSize,
2683     arg1: u32,
2684     arg2: Gpr,
2685 ) -> Option<ProducesFlags> {
2686     let pattern0_0 = arg0;
2687     let pattern1_0 = arg1;
2688     let pattern2_0 = arg2;
2689     // Rule at src/isa/x64/inst.isle line 1832.
2690     let expr0_0 = CmpOpcode::Cmp;
2691     let expr1_0 = RegMemImm::Imm { simm32: pattern1_0 };
2692     let expr2_0 = C::gpr_mem_imm_new(ctx, &expr1_0);
2693     let expr3_0 = constructor_cmp_rmi_r(ctx, pattern0_0, &expr0_0, &expr2_0, pattern2_0)?;
2694     return Some(expr3_0);
2695 }
2696 
2697 // Generated as internal constructor for term xmm_cmp_rm_r.
2698 pub fn constructor_xmm_cmp_rm_r<C: Context>(
2699     ctx: &mut C,
2700     arg0: &SseOpcode,
2701     arg1: &XmmMem,
2702     arg2: Xmm,
2703 ) -> Option<ProducesFlags> {
2704     let pattern0_0 = arg0;
2705     let pattern1_0 = arg1;
2706     let pattern2_0 = arg2;
2707     // Rule at src/isa/x64/inst.isle line 1837.
2708     let expr0_0 = MInst::XmmCmpRmR {
2709         op: pattern0_0.clone(),
2710         src: pattern1_0.clone(),
2711         dst: pattern2_0,
2712     };
2713     let expr1_0 = ProducesFlags::ProducesFlagsSideEffect { inst: expr0_0 };
2714     return Some(expr1_0);
2715 }
2716 
2717 // Generated as internal constructor for term x64_ucomis.
2718 pub fn constructor_x64_ucomis<C: Context>(
2719     ctx: &mut C,
2720     arg0: Value,
2721     arg1: Value,
2722 ) -> Option<ProducesFlags> {
2723     let pattern0_0 = arg0;
2724     let pattern1_0 = C::value_type(ctx, pattern0_0);
2725     if pattern1_0 == F32 {
2726         let pattern3_0 = arg1;
2727         // Rule at src/isa/x64/inst.isle line 1843.
2728         let expr0_0 = SseOpcode::Ucomiss;
2729         let expr1_0 = constructor_put_in_xmm(ctx, pattern0_0)?;
2730         let expr2_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
2731         let expr3_0 = constructor_put_in_xmm(ctx, pattern3_0)?;
2732         let expr4_0 = constructor_xmm_cmp_rm_r(ctx, &expr0_0, &expr2_0, expr3_0)?;
2733         return Some(expr4_0);
2734     }
2735     if pattern1_0 == F64 {
2736         let pattern3_0 = arg1;
2737         // Rule at src/isa/x64/inst.isle line 1847.
2738         let expr0_0 = SseOpcode::Ucomisd;
2739         let expr1_0 = constructor_put_in_xmm(ctx, pattern0_0)?;
2740         let expr2_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
2741         let expr3_0 = constructor_put_in_xmm(ctx, pattern3_0)?;
2742         let expr4_0 = constructor_xmm_cmp_rm_r(ctx, &expr0_0, &expr2_0, expr3_0)?;
2743         return Some(expr4_0);
2744     }
2745     return None;
2746 }
2747 
2748 // Generated as internal constructor for term x64_test.
2749 pub fn constructor_x64_test<C: Context>(
2750     ctx: &mut C,
2751     arg0: &OperandSize,
2752     arg1: &GprMemImm,
2753     arg2: Gpr,
2754 ) -> Option<ProducesFlags> {
2755     let pattern0_0 = arg0;
2756     let pattern1_0 = arg1;
2757     let pattern2_0 = arg2;
2758     // Rule at src/isa/x64/inst.isle line 1852.
2759     let expr0_0 = CmpOpcode::Test;
2760     let expr1_0 = constructor_cmp_rmi_r(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?;
2761     return Some(expr1_0);
2762 }
2763 
2764 // Generated as internal constructor for term cmove.
2765 pub fn constructor_cmove<C: Context>(
2766     ctx: &mut C,
2767     arg0: Type,
2768     arg1: &CC,
2769     arg2: &GprMem,
2770     arg3: Gpr,
2771 ) -> Option<ConsumesFlags> {
2772     let pattern0_0 = arg0;
2773     let pattern1_0 = arg1;
2774     let pattern2_0 = arg2;
2775     let pattern3_0 = arg3;
2776     // Rule at src/isa/x64/inst.isle line 1859.
2777     let expr0_0 = C::temp_writable_gpr(ctx);
2778     let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
2779     let expr2_0 = MInst::Cmove {
2780         size: expr1_0,
2781         cc: pattern1_0.clone(),
2782         consequent: pattern2_0.clone(),
2783         alternative: pattern3_0,
2784         dst: expr0_0,
2785     };
2786     let expr3_0 = constructor_writable_gpr_to_r_reg(ctx, expr0_0)?;
2787     let expr4_0 = ConsumesFlags::ConsumesFlagsReturnsReg {
2788         inst: expr2_0,
2789         result: expr3_0,
2790     };
2791     return Some(expr4_0);
2792 }
2793 
2794 // Generated as internal constructor for term cmove_xmm.
2795 pub fn constructor_cmove_xmm<C: Context>(
2796     ctx: &mut C,
2797     arg0: Type,
2798     arg1: &CC,
2799     arg2: &XmmMem,
2800     arg3: Xmm,
2801 ) -> Option<ConsumesFlags> {
2802     let pattern0_0 = arg0;
2803     let pattern1_0 = arg1;
2804     let pattern2_0 = arg2;
2805     let pattern3_0 = arg3;
2806     // Rule at src/isa/x64/inst.isle line 1867.
2807     let expr0_0 = C::temp_writable_xmm(ctx);
2808     let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
2809     let expr2_0 = MInst::XmmCmove {
2810         size: expr1_0,
2811         cc: pattern1_0.clone(),
2812         consequent: pattern2_0.clone(),
2813         alternative: pattern3_0,
2814         dst: expr0_0,
2815     };
2816     let expr3_0 = constructor_writable_xmm_to_r_reg(ctx, expr0_0)?;
2817     let expr4_0 = ConsumesFlags::ConsumesFlagsReturnsReg {
2818         inst: expr2_0,
2819         result: expr3_0,
2820     };
2821     return Some(expr4_0);
2822 }
2823 
2824 // Generated as internal constructor for term cmove_from_values.
2825 pub fn constructor_cmove_from_values<C: Context>(
2826     ctx: &mut C,
2827     arg0: Type,
2828     arg1: &CC,
2829     arg2: Value,
2830     arg3: Value,
2831 ) -> Option<ConsumesFlags> {
2832     let pattern0_0 = arg0;
2833     if pattern0_0 == I128 {
2834         let pattern2_0 = arg1;
2835         let pattern3_0 = arg2;
2836         let pattern4_0 = arg3;
2837         // Rule at src/isa/x64/inst.isle line 1878.
2838         let expr0_0 = C::put_in_regs(ctx, pattern3_0);
2839         let expr1_0 = C::put_in_regs(ctx, pattern4_0);
2840         let expr2_0 = C::temp_writable_gpr(ctx);
2841         let expr3_0 = C::temp_writable_gpr(ctx);
2842         let expr4_0 = OperandSize::Size64;
2843         let expr5_0: usize = 0;
2844         let expr6_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr5_0)?;
2845         let expr7_0 = C::gpr_to_gpr_mem(ctx, expr6_0);
2846         let expr8_0: usize = 0;
2847         let expr9_0 = constructor_value_regs_get_gpr(ctx, expr1_0, expr8_0)?;
2848         let expr10_0 = MInst::Cmove {
2849             size: expr4_0,
2850             cc: pattern2_0.clone(),
2851             consequent: expr7_0,
2852             alternative: expr9_0,
2853             dst: expr2_0,
2854         };
2855         let expr11_0: usize = 1;
2856         let expr12_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr11_0)?;
2857         let expr13_0 = C::gpr_to_gpr_mem(ctx, expr12_0);
2858         let expr14_0: usize = 1;
2859         let expr15_0 = constructor_value_regs_get_gpr(ctx, expr1_0, expr14_0)?;
2860         let expr16_0 = MInst::Cmove {
2861             size: expr4_0,
2862             cc: pattern2_0.clone(),
2863             consequent: expr13_0,
2864             alternative: expr15_0,
2865             dst: expr3_0,
2866         };
2867         let expr17_0 = constructor_writable_gpr_to_r_reg(ctx, expr2_0)?;
2868         let expr18_0 = constructor_writable_gpr_to_r_reg(ctx, expr3_0)?;
2869         let expr19_0 = C::value_regs(ctx, expr17_0, expr18_0);
2870         let expr20_0 = ConsumesFlags::ConsumesFlagsTwiceReturnsValueRegs {
2871             inst1: expr10_0,
2872             inst2: expr16_0,
2873             result: expr19_0,
2874         };
2875         return Some(expr20_0);
2876     }
2877     if let Some(pattern1_0) = C::is_xmm_type(ctx, pattern0_0) {
2878         if let Some(pattern2_0) = C::is_single_register_type(ctx, pattern1_0) {
2879             let pattern3_0 = arg1;
2880             let pattern4_0 = arg2;
2881             let pattern5_0 = arg3;
2882             // Rule at src/isa/x64/inst.isle line 1902.
2883             let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern4_0)?;
2884             let expr1_0 = constructor_put_in_xmm(ctx, pattern5_0)?;
2885             let expr2_0 = constructor_cmove_xmm(ctx, pattern2_0, pattern3_0, &expr0_0, expr1_0)?;
2886             return Some(expr2_0);
2887         }
2888     }
2889     if let Some(pattern1_0) = C::is_gpr_type(ctx, pattern0_0) {
2890         if let Some(pattern2_0) = C::is_single_register_type(ctx, pattern1_0) {
2891             let pattern3_0 = arg1;
2892             let pattern4_0 = arg2;
2893             let pattern5_0 = arg3;
2894             // Rule at src/isa/x64/inst.isle line 1899.
2895             let expr0_0 = constructor_put_in_gpr_mem(ctx, pattern4_0)?;
2896             let expr1_0 = constructor_put_in_gpr(ctx, pattern5_0)?;
2897             let expr2_0 = constructor_cmove(ctx, pattern2_0, pattern3_0, &expr0_0, expr1_0)?;
2898             return Some(expr2_0);
2899         }
2900     }
2901     return None;
2902 }
2903 
2904 // Generated as internal constructor for term cmove_or.
2905 pub fn constructor_cmove_or<C: Context>(
2906     ctx: &mut C,
2907     arg0: Type,
2908     arg1: &CC,
2909     arg2: &CC,
2910     arg3: &GprMem,
2911     arg4: Gpr,
2912 ) -> Option<ConsumesFlags> {
2913     let pattern0_0 = arg0;
2914     let pattern1_0 = arg1;
2915     let pattern2_0 = arg2;
2916     let pattern3_0 = arg3;
2917     let pattern4_0 = arg4;
2918     // Rule at src/isa/x64/inst.isle line 1909.
2919     let expr0_0 = C::temp_writable_gpr(ctx);
2920     let expr1_0 = C::temp_writable_gpr(ctx);
2921     let expr2_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
2922     let expr3_0 = MInst::Cmove {
2923         size: expr2_0,
2924         cc: pattern1_0.clone(),
2925         consequent: pattern3_0.clone(),
2926         alternative: pattern4_0,
2927         dst: expr1_0,
2928     };
2929     let expr4_0 = C::writable_gpr_to_gpr(ctx, expr1_0);
2930     let expr5_0 = MInst::Cmove {
2931         size: expr2_0,
2932         cc: pattern2_0.clone(),
2933         consequent: pattern3_0.clone(),
2934         alternative: expr4_0,
2935         dst: expr0_0,
2936     };
2937     let expr6_0 = constructor_writable_gpr_to_value_regs(ctx, expr0_0)?;
2938     let expr7_0 = ConsumesFlags::ConsumesFlagsTwiceReturnsValueRegs {
2939         inst1: expr3_0,
2940         inst2: expr5_0,
2941         result: expr6_0,
2942     };
2943     return Some(expr7_0);
2944 }
2945 
2946 // Generated as internal constructor for term cmove_or_xmm.
2947 pub fn constructor_cmove_or_xmm<C: Context>(
2948     ctx: &mut C,
2949     arg0: Type,
2950     arg1: &CC,
2951     arg2: &CC,
2952     arg3: &XmmMem,
2953     arg4: Xmm,
2954 ) -> Option<ConsumesFlags> {
2955     let pattern0_0 = arg0;
2956     let pattern1_0 = arg1;
2957     let pattern2_0 = arg2;
2958     let pattern3_0 = arg3;
2959     let pattern4_0 = arg4;
2960     // Rule at src/isa/x64/inst.isle line 1921.
2961     let expr0_0 = C::temp_writable_xmm(ctx);
2962     let expr1_0 = C::temp_writable_xmm(ctx);
2963     let expr2_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
2964     let expr3_0 = MInst::XmmCmove {
2965         size: expr2_0,
2966         cc: pattern1_0.clone(),
2967         consequent: pattern3_0.clone(),
2968         alternative: pattern4_0,
2969         dst: expr1_0,
2970     };
2971     let expr4_0 = C::writable_xmm_to_xmm(ctx, expr1_0);
2972     let expr5_0 = MInst::XmmCmove {
2973         size: expr2_0,
2974         cc: pattern2_0.clone(),
2975         consequent: pattern3_0.clone(),
2976         alternative: expr4_0,
2977         dst: expr0_0,
2978     };
2979     let expr6_0 = constructor_writable_xmm_to_value_regs(ctx, expr0_0)?;
2980     let expr7_0 = ConsumesFlags::ConsumesFlagsTwiceReturnsValueRegs {
2981         inst1: expr3_0,
2982         inst2: expr5_0,
2983         result: expr6_0,
2984     };
2985     return Some(expr7_0);
2986 }
2987 
2988 // Generated as internal constructor for term cmove_or_from_values.
2989 pub fn constructor_cmove_or_from_values<C: Context>(
2990     ctx: &mut C,
2991     arg0: Type,
2992     arg1: &CC,
2993     arg2: &CC,
2994     arg3: Value,
2995     arg4: Value,
2996 ) -> Option<ConsumesFlags> {
2997     let pattern0_0 = arg0;
2998     if pattern0_0 == I128 {
2999         let pattern2_0 = arg1;
3000         let pattern3_0 = arg2;
3001         let pattern4_0 = arg3;
3002         let pattern5_0 = arg4;
3003         // Rule at src/isa/x64/inst.isle line 1936.
3004         let expr0_0 = C::put_in_regs(ctx, pattern4_0);
3005         let expr1_0 = C::put_in_regs(ctx, pattern5_0);
3006         let expr2_0 = C::temp_writable_gpr(ctx);
3007         let expr3_0 = C::temp_writable_gpr(ctx);
3008         let expr4_0 = C::temp_writable_gpr(ctx);
3009         let expr5_0 = C::temp_writable_gpr(ctx);
3010         let expr6_0 = OperandSize::Size64;
3011         let expr7_0: usize = 0;
3012         let expr8_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr7_0)?;
3013         let expr9_0 = C::gpr_to_gpr_mem(ctx, expr8_0);
3014         let expr10_0: usize = 0;
3015         let expr11_0 = constructor_value_regs_get_gpr(ctx, expr1_0, expr10_0)?;
3016         let expr12_0 = MInst::Cmove {
3017             size: expr6_0,
3018             cc: pattern2_0.clone(),
3019             consequent: expr9_0,
3020             alternative: expr11_0,
3021             dst: expr4_0,
3022         };
3023         let expr13_0: usize = 0;
3024         let expr14_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr13_0)?;
3025         let expr15_0 = C::gpr_to_gpr_mem(ctx, expr14_0);
3026         let expr16_0 = C::writable_gpr_to_gpr(ctx, expr4_0);
3027         let expr17_0 = MInst::Cmove {
3028             size: expr6_0,
3029             cc: pattern3_0.clone(),
3030             consequent: expr15_0,
3031             alternative: expr16_0,
3032             dst: expr2_0,
3033         };
3034         let expr18_0: usize = 1;
3035         let expr19_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr18_0)?;
3036         let expr20_0 = C::gpr_to_gpr_mem(ctx, expr19_0);
3037         let expr21_0: usize = 1;
3038         let expr22_0 = constructor_value_regs_get_gpr(ctx, expr1_0, expr21_0)?;
3039         let expr23_0 = MInst::Cmove {
3040             size: expr6_0,
3041             cc: pattern2_0.clone(),
3042             consequent: expr20_0,
3043             alternative: expr22_0,
3044             dst: expr5_0,
3045         };
3046         let expr24_0: usize = 1;
3047         let expr25_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr24_0)?;
3048         let expr26_0 = C::gpr_to_gpr_mem(ctx, expr25_0);
3049         let expr27_0 = C::writable_gpr_to_gpr(ctx, expr5_0);
3050         let expr28_0 = MInst::Cmove {
3051             size: expr6_0,
3052             cc: pattern3_0.clone(),
3053             consequent: expr26_0,
3054             alternative: expr27_0,
3055             dst: expr3_0,
3056         };
3057         let expr29_0 = constructor_writable_gpr_to_r_reg(ctx, expr2_0)?;
3058         let expr30_0 = constructor_writable_gpr_to_r_reg(ctx, expr3_0)?;
3059         let expr31_0 = C::value_regs(ctx, expr29_0, expr30_0);
3060         let expr32_0 = ConsumesFlags::ConsumesFlagsFourTimesReturnsValueRegs {
3061             inst1: expr12_0,
3062             inst2: expr17_0,
3063             inst3: expr23_0,
3064             inst4: expr28_0,
3065             result: expr31_0,
3066         };
3067         return Some(expr32_0);
3068     }
3069     if let Some(pattern1_0) = C::is_xmm_type(ctx, pattern0_0) {
3070         if let Some(pattern2_0) = C::is_single_register_type(ctx, pattern1_0) {
3071             let pattern3_0 = arg1;
3072             let pattern4_0 = arg2;
3073             let pattern5_0 = arg3;
3074             let pattern6_0 = arg4;
3075             // Rule at src/isa/x64/inst.isle line 1958.
3076             let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern5_0)?;
3077             let expr1_0 = constructor_put_in_xmm(ctx, pattern6_0)?;
3078             let expr2_0 = constructor_cmove_or_xmm(
3079                 ctx, pattern2_0, pattern3_0, pattern4_0, &expr0_0, expr1_0,
3080             )?;
3081             return Some(expr2_0);
3082         }
3083     }
3084     if let Some(pattern1_0) = C::is_gpr_type(ctx, pattern0_0) {
3085         if let Some(pattern2_0) = C::is_single_register_type(ctx, pattern1_0) {
3086             let pattern3_0 = arg1;
3087             let pattern4_0 = arg2;
3088             let pattern5_0 = arg3;
3089             let pattern6_0 = arg4;
3090             // Rule at src/isa/x64/inst.isle line 1955.
3091             let expr0_0 = constructor_put_in_gpr_mem(ctx, pattern5_0)?;
3092             let expr1_0 = constructor_put_in_gpr(ctx, pattern6_0)?;
3093             let expr2_0 =
3094                 constructor_cmove_or(ctx, pattern2_0, pattern3_0, pattern4_0, &expr0_0, expr1_0)?;
3095             return Some(expr2_0);
3096         }
3097     }
3098     return None;
3099 }
3100 
3101 // Generated as internal constructor for term x64_setcc.
3102 pub fn constructor_x64_setcc<C: Context>(ctx: &mut C, arg0: &CC) -> Option<ConsumesFlags> {
3103     let pattern0_0 = arg0;
3104     // Rule at src/isa/x64/inst.isle line 1963.
3105     let expr0_0 = C::temp_writable_gpr(ctx);
3106     let expr1_0 = MInst::Setcc {
3107         cc: pattern0_0.clone(),
3108         dst: expr0_0,
3109     };
3110     let expr2_0 = constructor_writable_gpr_to_r_reg(ctx, expr0_0)?;
3111     let expr3_0 = ConsumesFlags::ConsumesFlagsReturnsReg {
3112         inst: expr1_0,
3113         result: expr2_0,
3114     };
3115     return Some(expr3_0);
3116 }
3117 
3118 // Generated as internal constructor for term xmm_rm_r.
3119 pub fn constructor_xmm_rm_r<C: Context>(
3120     ctx: &mut C,
3121     arg0: Type,
3122     arg1: &SseOpcode,
3123     arg2: Xmm,
3124     arg3: &XmmMem,
3125 ) -> Option<Xmm> {
3126     let pattern0_0 = arg0;
3127     let pattern1_0 = arg1;
3128     let pattern2_0 = arg2;
3129     let pattern3_0 = arg3;
3130     // Rule at src/isa/x64/inst.isle line 1971.
3131     let expr0_0 = C::temp_writable_xmm(ctx);
3132     let expr1_0 = MInst::XmmRmR {
3133         op: pattern1_0.clone(),
3134         src1: pattern2_0,
3135         src2: pattern3_0.clone(),
3136         dst: expr0_0,
3137     };
3138     let expr2_0 = C::emit(ctx, &expr1_0);
3139     let expr3_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
3140     return Some(expr3_0);
3141 }
3142 
3143 // Generated as internal constructor for term x64_paddb.
3144 pub fn constructor_x64_paddb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3145     let pattern0_0 = arg0;
3146     let pattern1_0 = arg1;
3147     // Rule at src/isa/x64/inst.isle line 1978.
3148     let expr0_0: Type = I8X16;
3149     let expr1_0 = SseOpcode::Paddb;
3150     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3151     return Some(expr2_0);
3152 }
3153 
3154 // Generated as internal constructor for term x64_paddw.
3155 pub fn constructor_x64_paddw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3156     let pattern0_0 = arg0;
3157     let pattern1_0 = arg1;
3158     // Rule at src/isa/x64/inst.isle line 1983.
3159     let expr0_0: Type = I16X8;
3160     let expr1_0 = SseOpcode::Paddw;
3161     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3162     return Some(expr2_0);
3163 }
3164 
3165 // Generated as internal constructor for term x64_paddd.
3166 pub fn constructor_x64_paddd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3167     let pattern0_0 = arg0;
3168     let pattern1_0 = arg1;
3169     // Rule at src/isa/x64/inst.isle line 1988.
3170     let expr0_0: Type = I32X4;
3171     let expr1_0 = SseOpcode::Paddd;
3172     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3173     return Some(expr2_0);
3174 }
3175 
3176 // Generated as internal constructor for term x64_paddq.
3177 pub fn constructor_x64_paddq<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3178     let pattern0_0 = arg0;
3179     let pattern1_0 = arg1;
3180     // Rule at src/isa/x64/inst.isle line 1993.
3181     let expr0_0: Type = I64X2;
3182     let expr1_0 = SseOpcode::Paddq;
3183     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3184     return Some(expr2_0);
3185 }
3186 
3187 // Generated as internal constructor for term x64_paddsb.
3188 pub fn constructor_x64_paddsb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3189     let pattern0_0 = arg0;
3190     let pattern1_0 = arg1;
3191     // Rule at src/isa/x64/inst.isle line 1998.
3192     let expr0_0: Type = I8X16;
3193     let expr1_0 = SseOpcode::Paddsb;
3194     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3195     return Some(expr2_0);
3196 }
3197 
3198 // Generated as internal constructor for term x64_paddsw.
3199 pub fn constructor_x64_paddsw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3200     let pattern0_0 = arg0;
3201     let pattern1_0 = arg1;
3202     // Rule at src/isa/x64/inst.isle line 2003.
3203     let expr0_0: Type = I16X8;
3204     let expr1_0 = SseOpcode::Paddsw;
3205     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3206     return Some(expr2_0);
3207 }
3208 
3209 // Generated as internal constructor for term x64_paddusb.
3210 pub fn constructor_x64_paddusb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3211     let pattern0_0 = arg0;
3212     let pattern1_0 = arg1;
3213     // Rule at src/isa/x64/inst.isle line 2008.
3214     let expr0_0: Type = I8X16;
3215     let expr1_0 = SseOpcode::Paddusb;
3216     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3217     return Some(expr2_0);
3218 }
3219 
3220 // Generated as internal constructor for term x64_paddusw.
3221 pub fn constructor_x64_paddusw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3222     let pattern0_0 = arg0;
3223     let pattern1_0 = arg1;
3224     // Rule at src/isa/x64/inst.isle line 2013.
3225     let expr0_0: Type = I16X8;
3226     let expr1_0 = SseOpcode::Paddusw;
3227     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3228     return Some(expr2_0);
3229 }
3230 
3231 // Generated as internal constructor for term x64_psubb.
3232 pub fn constructor_x64_psubb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3233     let pattern0_0 = arg0;
3234     let pattern1_0 = arg1;
3235     // Rule at src/isa/x64/inst.isle line 2018.
3236     let expr0_0: Type = I8X16;
3237     let expr1_0 = SseOpcode::Psubb;
3238     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3239     return Some(expr2_0);
3240 }
3241 
3242 // Generated as internal constructor for term x64_psubw.
3243 pub fn constructor_x64_psubw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3244     let pattern0_0 = arg0;
3245     let pattern1_0 = arg1;
3246     // Rule at src/isa/x64/inst.isle line 2023.
3247     let expr0_0: Type = I16X8;
3248     let expr1_0 = SseOpcode::Psubw;
3249     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3250     return Some(expr2_0);
3251 }
3252 
3253 // Generated as internal constructor for term x64_psubd.
3254 pub fn constructor_x64_psubd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3255     let pattern0_0 = arg0;
3256     let pattern1_0 = arg1;
3257     // Rule at src/isa/x64/inst.isle line 2028.
3258     let expr0_0: Type = I32X4;
3259     let expr1_0 = SseOpcode::Psubd;
3260     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3261     return Some(expr2_0);
3262 }
3263 
3264 // Generated as internal constructor for term x64_psubq.
3265 pub fn constructor_x64_psubq<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3266     let pattern0_0 = arg0;
3267     let pattern1_0 = arg1;
3268     // Rule at src/isa/x64/inst.isle line 2033.
3269     let expr0_0: Type = I64X2;
3270     let expr1_0 = SseOpcode::Psubq;
3271     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3272     return Some(expr2_0);
3273 }
3274 
3275 // Generated as internal constructor for term x64_psubsb.
3276 pub fn constructor_x64_psubsb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3277     let pattern0_0 = arg0;
3278     let pattern1_0 = arg1;
3279     // Rule at src/isa/x64/inst.isle line 2038.
3280     let expr0_0: Type = I8X16;
3281     let expr1_0 = SseOpcode::Psubsb;
3282     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3283     return Some(expr2_0);
3284 }
3285 
3286 // Generated as internal constructor for term x64_psubsw.
3287 pub fn constructor_x64_psubsw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3288     let pattern0_0 = arg0;
3289     let pattern1_0 = arg1;
3290     // Rule at src/isa/x64/inst.isle line 2043.
3291     let expr0_0: Type = I16X8;
3292     let expr1_0 = SseOpcode::Psubsw;
3293     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3294     return Some(expr2_0);
3295 }
3296 
3297 // Generated as internal constructor for term x64_psubusb.
3298 pub fn constructor_x64_psubusb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3299     let pattern0_0 = arg0;
3300     let pattern1_0 = arg1;
3301     // Rule at src/isa/x64/inst.isle line 2048.
3302     let expr0_0: Type = I8X16;
3303     let expr1_0 = SseOpcode::Psubusb;
3304     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3305     return Some(expr2_0);
3306 }
3307 
3308 // Generated as internal constructor for term x64_psubusw.
3309 pub fn constructor_x64_psubusw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3310     let pattern0_0 = arg0;
3311     let pattern1_0 = arg1;
3312     // Rule at src/isa/x64/inst.isle line 2053.
3313     let expr0_0: Type = I16X8;
3314     let expr1_0 = SseOpcode::Psubusw;
3315     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3316     return Some(expr2_0);
3317 }
3318 
3319 // Generated as internal constructor for term x64_pavgb.
3320 pub fn constructor_x64_pavgb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3321     let pattern0_0 = arg0;
3322     let pattern1_0 = arg1;
3323     // Rule at src/isa/x64/inst.isle line 2058.
3324     let expr0_0: Type = I8X16;
3325     let expr1_0 = SseOpcode::Pavgb;
3326     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3327     return Some(expr2_0);
3328 }
3329 
3330 // Generated as internal constructor for term x64_pavgw.
3331 pub fn constructor_x64_pavgw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3332     let pattern0_0 = arg0;
3333     let pattern1_0 = arg1;
3334     // Rule at src/isa/x64/inst.isle line 2063.
3335     let expr0_0: Type = I16X8;
3336     let expr1_0 = SseOpcode::Pavgw;
3337     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3338     return Some(expr2_0);
3339 }
3340 
3341 // Generated as internal constructor for term x64_pand.
3342 pub fn constructor_x64_pand<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3343     let pattern0_0 = arg0;
3344     let pattern1_0 = arg1;
3345     // Rule at src/isa/x64/inst.isle line 2068.
3346     let expr0_0: Type = F32X4;
3347     let expr1_0 = SseOpcode::Pand;
3348     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3349     return Some(expr2_0);
3350 }
3351 
3352 // Generated as internal constructor for term x64_andps.
3353 pub fn constructor_x64_andps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3354     let pattern0_0 = arg0;
3355     let pattern1_0 = arg1;
3356     // Rule at src/isa/x64/inst.isle line 2073.
3357     let expr0_0: Type = F32X4;
3358     let expr1_0 = SseOpcode::Andps;
3359     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3360     return Some(expr2_0);
3361 }
3362 
3363 // Generated as internal constructor for term x64_andpd.
3364 pub fn constructor_x64_andpd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3365     let pattern0_0 = arg0;
3366     let pattern1_0 = arg1;
3367     // Rule at src/isa/x64/inst.isle line 2078.
3368     let expr0_0: Type = F64X2;
3369     let expr1_0 = SseOpcode::Andpd;
3370     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3371     return Some(expr2_0);
3372 }
3373 
3374 // Generated as internal constructor for term x64_por.
3375 pub fn constructor_x64_por<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3376     let pattern0_0 = arg0;
3377     let pattern1_0 = arg1;
3378     // Rule at src/isa/x64/inst.isle line 2083.
3379     let expr0_0: Type = F32X4;
3380     let expr1_0 = SseOpcode::Por;
3381     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3382     return Some(expr2_0);
3383 }
3384 
3385 // Generated as internal constructor for term x64_orps.
3386 pub fn constructor_x64_orps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3387     let pattern0_0 = arg0;
3388     let pattern1_0 = arg1;
3389     // Rule at src/isa/x64/inst.isle line 2088.
3390     let expr0_0: Type = F32X4;
3391     let expr1_0 = SseOpcode::Orps;
3392     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3393     return Some(expr2_0);
3394 }
3395 
3396 // Generated as internal constructor for term x64_orpd.
3397 pub fn constructor_x64_orpd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3398     let pattern0_0 = arg0;
3399     let pattern1_0 = arg1;
3400     // Rule at src/isa/x64/inst.isle line 2093.
3401     let expr0_0: Type = F64X2;
3402     let expr1_0 = SseOpcode::Orpd;
3403     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3404     return Some(expr2_0);
3405 }
3406 
3407 // Generated as internal constructor for term x64_pxor.
3408 pub fn constructor_x64_pxor<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3409     let pattern0_0 = arg0;
3410     let pattern1_0 = arg1;
3411     // Rule at src/isa/x64/inst.isle line 2098.
3412     let expr0_0: Type = I8X16;
3413     let expr1_0 = SseOpcode::Pxor;
3414     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3415     return Some(expr2_0);
3416 }
3417 
3418 // Generated as internal constructor for term x64_xorps.
3419 pub fn constructor_x64_xorps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3420     let pattern0_0 = arg0;
3421     let pattern1_0 = arg1;
3422     // Rule at src/isa/x64/inst.isle line 2103.
3423     let expr0_0: Type = F32X4;
3424     let expr1_0 = SseOpcode::Xorps;
3425     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3426     return Some(expr2_0);
3427 }
3428 
3429 // Generated as internal constructor for term x64_xorpd.
3430 pub fn constructor_x64_xorpd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3431     let pattern0_0 = arg0;
3432     let pattern1_0 = arg1;
3433     // Rule at src/isa/x64/inst.isle line 2108.
3434     let expr0_0: Type = F64X2;
3435     let expr1_0 = SseOpcode::Xorpd;
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_pmullw.
3441 pub fn constructor_x64_pmullw<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 2113.
3445     let expr0_0: Type = I16X8;
3446     let expr1_0 = SseOpcode::Pmullw;
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_pmulld.
3452 pub fn constructor_x64_pmulld<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3453     let pattern0_0 = arg0;
3454     let pattern1_0 = arg1;
3455     // Rule at src/isa/x64/inst.isle line 2118.
3456     let expr0_0: Type = I16X8;
3457     let expr1_0 = SseOpcode::Pmulld;
3458     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3459     return Some(expr2_0);
3460 }
3461 
3462 // Generated as internal constructor for term x64_pmulhw.
3463 pub fn constructor_x64_pmulhw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3464     let pattern0_0 = arg0;
3465     let pattern1_0 = arg1;
3466     // Rule at src/isa/x64/inst.isle line 2123.
3467     let expr0_0: Type = I16X8;
3468     let expr1_0 = SseOpcode::Pmulhw;
3469     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3470     return Some(expr2_0);
3471 }
3472 
3473 // Generated as internal constructor for term x64_pmulhuw.
3474 pub fn constructor_x64_pmulhuw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3475     let pattern0_0 = arg0;
3476     let pattern1_0 = arg1;
3477     // Rule at src/isa/x64/inst.isle line 2128.
3478     let expr0_0: Type = I16X8;
3479     let expr1_0 = SseOpcode::Pmulhuw;
3480     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3481     return Some(expr2_0);
3482 }
3483 
3484 // Generated as internal constructor for term x64_pmuldq.
3485 pub fn constructor_x64_pmuldq<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3486     let pattern0_0 = arg0;
3487     let pattern1_0 = arg1;
3488     // Rule at src/isa/x64/inst.isle line 2133.
3489     let expr0_0: Type = I16X8;
3490     let expr1_0 = SseOpcode::Pmuldq;
3491     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3492     return Some(expr2_0);
3493 }
3494 
3495 // Generated as internal constructor for term x64_pmuludq.
3496 pub fn constructor_x64_pmuludq<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3497     let pattern0_0 = arg0;
3498     let pattern1_0 = arg1;
3499     // Rule at src/isa/x64/inst.isle line 2138.
3500     let expr0_0: Type = I64X2;
3501     let expr1_0 = SseOpcode::Pmuludq;
3502     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3503     return Some(expr2_0);
3504 }
3505 
3506 // Generated as internal constructor for term x64_punpckhwd.
3507 pub fn constructor_x64_punpckhwd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3508     let pattern0_0 = arg0;
3509     let pattern1_0 = arg1;
3510     // Rule at src/isa/x64/inst.isle line 2143.
3511     let expr0_0: Type = I16X8;
3512     let expr1_0 = SseOpcode::Punpckhwd;
3513     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3514     return Some(expr2_0);
3515 }
3516 
3517 // Generated as internal constructor for term x64_punpcklwd.
3518 pub fn constructor_x64_punpcklwd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3519     let pattern0_0 = arg0;
3520     let pattern1_0 = arg1;
3521     // Rule at src/isa/x64/inst.isle line 2148.
3522     let expr0_0: Type = I16X8;
3523     let expr1_0 = SseOpcode::Punpcklwd;
3524     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3525     return Some(expr2_0);
3526 }
3527 
3528 // Generated as internal constructor for term x64_andnps.
3529 pub fn constructor_x64_andnps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3530     let pattern0_0 = arg0;
3531     let pattern1_0 = arg1;
3532     // Rule at src/isa/x64/inst.isle line 2153.
3533     let expr0_0: Type = F32X4;
3534     let expr1_0 = SseOpcode::Andnps;
3535     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3536     return Some(expr2_0);
3537 }
3538 
3539 // Generated as internal constructor for term x64_andnpd.
3540 pub fn constructor_x64_andnpd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3541     let pattern0_0 = arg0;
3542     let pattern1_0 = arg1;
3543     // Rule at src/isa/x64/inst.isle line 2158.
3544     let expr0_0: Type = F64X2;
3545     let expr1_0 = SseOpcode::Andnpd;
3546     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3547     return Some(expr2_0);
3548 }
3549 
3550 // Generated as internal constructor for term x64_pandn.
3551 pub fn constructor_x64_pandn<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3552     let pattern0_0 = arg0;
3553     let pattern1_0 = arg1;
3554     // Rule at src/isa/x64/inst.isle line 2163.
3555     let expr0_0: Type = F64X2;
3556     let expr1_0 = SseOpcode::Pandn;
3557     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3558     return Some(expr2_0);
3559 }
3560 
3561 // Generated as internal constructor for term x64_addss.
3562 pub fn constructor_x64_addss<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3563     let pattern0_0 = arg0;
3564     let pattern1_0 = arg1;
3565     // Rule at src/isa/x64/inst.isle line 2168.
3566     let expr0_0: Type = F32;
3567     let expr1_0 = SseOpcode::Addss;
3568     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3569     return Some(expr2_0);
3570 }
3571 
3572 // Generated as internal constructor for term x64_addsd.
3573 pub fn constructor_x64_addsd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3574     let pattern0_0 = arg0;
3575     let pattern1_0 = arg1;
3576     // Rule at src/isa/x64/inst.isle line 2173.
3577     let expr0_0: Type = F64;
3578     let expr1_0 = SseOpcode::Addsd;
3579     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3580     return Some(expr2_0);
3581 }
3582 
3583 // Generated as internal constructor for term x64_addps.
3584 pub fn constructor_x64_addps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3585     let pattern0_0 = arg0;
3586     let pattern1_0 = arg1;
3587     // Rule at src/isa/x64/inst.isle line 2178.
3588     let expr0_0: Type = F32;
3589     let expr1_0 = SseOpcode::Addps;
3590     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3591     return Some(expr2_0);
3592 }
3593 
3594 // Generated as internal constructor for term x64_addpd.
3595 pub fn constructor_x64_addpd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3596     let pattern0_0 = arg0;
3597     let pattern1_0 = arg1;
3598     // Rule at src/isa/x64/inst.isle line 2183.
3599     let expr0_0: Type = F32;
3600     let expr1_0 = SseOpcode::Addpd;
3601     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3602     return Some(expr2_0);
3603 }
3604 
3605 // Generated as internal constructor for term x64_subss.
3606 pub fn constructor_x64_subss<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3607     let pattern0_0 = arg0;
3608     let pattern1_0 = arg1;
3609     // Rule at src/isa/x64/inst.isle line 2188.
3610     let expr0_0: Type = F32;
3611     let expr1_0 = SseOpcode::Subss;
3612     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3613     return Some(expr2_0);
3614 }
3615 
3616 // Generated as internal constructor for term x64_subsd.
3617 pub fn constructor_x64_subsd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3618     let pattern0_0 = arg0;
3619     let pattern1_0 = arg1;
3620     // Rule at src/isa/x64/inst.isle line 2193.
3621     let expr0_0: Type = F64;
3622     let expr1_0 = SseOpcode::Subsd;
3623     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3624     return Some(expr2_0);
3625 }
3626 
3627 // Generated as internal constructor for term x64_subps.
3628 pub fn constructor_x64_subps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3629     let pattern0_0 = arg0;
3630     let pattern1_0 = arg1;
3631     // Rule at src/isa/x64/inst.isle line 2198.
3632     let expr0_0: Type = F32;
3633     let expr1_0 = SseOpcode::Subps;
3634     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3635     return Some(expr2_0);
3636 }
3637 
3638 // Generated as internal constructor for term x64_subpd.
3639 pub fn constructor_x64_subpd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3640     let pattern0_0 = arg0;
3641     let pattern1_0 = arg1;
3642     // Rule at src/isa/x64/inst.isle line 2203.
3643     let expr0_0: Type = F32;
3644     let expr1_0 = SseOpcode::Subpd;
3645     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3646     return Some(expr2_0);
3647 }
3648 
3649 // Generated as internal constructor for term x64_mulss.
3650 pub fn constructor_x64_mulss<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3651     let pattern0_0 = arg0;
3652     let pattern1_0 = arg1;
3653     // Rule at src/isa/x64/inst.isle line 2208.
3654     let expr0_0: Type = F32;
3655     let expr1_0 = SseOpcode::Mulss;
3656     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3657     return Some(expr2_0);
3658 }
3659 
3660 // Generated as internal constructor for term x64_mulsd.
3661 pub fn constructor_x64_mulsd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3662     let pattern0_0 = arg0;
3663     let pattern1_0 = arg1;
3664     // Rule at src/isa/x64/inst.isle line 2213.
3665     let expr0_0: Type = F64;
3666     let expr1_0 = SseOpcode::Mulsd;
3667     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3668     return Some(expr2_0);
3669 }
3670 
3671 // Generated as internal constructor for term x64_mulps.
3672 pub fn constructor_x64_mulps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3673     let pattern0_0 = arg0;
3674     let pattern1_0 = arg1;
3675     // Rule at src/isa/x64/inst.isle line 2218.
3676     let expr0_0: Type = F32;
3677     let expr1_0 = SseOpcode::Mulps;
3678     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3679     return Some(expr2_0);
3680 }
3681 
3682 // Generated as internal constructor for term x64_mulpd.
3683 pub fn constructor_x64_mulpd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3684     let pattern0_0 = arg0;
3685     let pattern1_0 = arg1;
3686     // Rule at src/isa/x64/inst.isle line 2223.
3687     let expr0_0: Type = F32;
3688     let expr1_0 = SseOpcode::Mulpd;
3689     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3690     return Some(expr2_0);
3691 }
3692 
3693 // Generated as internal constructor for term x64_divss.
3694 pub fn constructor_x64_divss<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3695     let pattern0_0 = arg0;
3696     let pattern1_0 = arg1;
3697     // Rule at src/isa/x64/inst.isle line 2228.
3698     let expr0_0: Type = F32;
3699     let expr1_0 = SseOpcode::Divss;
3700     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3701     return Some(expr2_0);
3702 }
3703 
3704 // Generated as internal constructor for term x64_divsd.
3705 pub fn constructor_x64_divsd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3706     let pattern0_0 = arg0;
3707     let pattern1_0 = arg1;
3708     // Rule at src/isa/x64/inst.isle line 2233.
3709     let expr0_0: Type = F64;
3710     let expr1_0 = SseOpcode::Divsd;
3711     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3712     return Some(expr2_0);
3713 }
3714 
3715 // Generated as internal constructor for term x64_divps.
3716 pub fn constructor_x64_divps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3717     let pattern0_0 = arg0;
3718     let pattern1_0 = arg1;
3719     // Rule at src/isa/x64/inst.isle line 2238.
3720     let expr0_0: Type = F32;
3721     let expr1_0 = SseOpcode::Divps;
3722     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3723     return Some(expr2_0);
3724 }
3725 
3726 // Generated as internal constructor for term x64_divpd.
3727 pub fn constructor_x64_divpd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3728     let pattern0_0 = arg0;
3729     let pattern1_0 = arg1;
3730     // Rule at src/isa/x64/inst.isle line 2243.
3731     let expr0_0: Type = F32;
3732     let expr1_0 = SseOpcode::Divpd;
3733     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3734     return Some(expr2_0);
3735 }
3736 
3737 // Generated as internal constructor for term sse_blend_op.
3738 pub fn constructor_sse_blend_op<C: Context>(ctx: &mut C, arg0: Type) -> Option<SseOpcode> {
3739     let pattern0_0 = arg0;
3740     if pattern0_0 == F32X4 {
3741         // Rule at src/isa/x64/inst.isle line 2247.
3742         let expr0_0 = SseOpcode::Blendvps;
3743         return Some(expr0_0);
3744     }
3745     if pattern0_0 == F64X2 {
3746         // Rule at src/isa/x64/inst.isle line 2248.
3747         let expr0_0 = SseOpcode::Blendvpd;
3748         return Some(expr0_0);
3749     }
3750     if let Some((pattern1_0, pattern1_1)) = C::multi_lane(ctx, pattern0_0) {
3751         // Rule at src/isa/x64/inst.isle line 2249.
3752         let expr0_0 = SseOpcode::Pblendvb;
3753         return Some(expr0_0);
3754     }
3755     return None;
3756 }
3757 
3758 // Generated as internal constructor for term sse_mov_op.
3759 pub fn constructor_sse_mov_op<C: Context>(ctx: &mut C, arg0: Type) -> Option<SseOpcode> {
3760     let pattern0_0 = arg0;
3761     if pattern0_0 == F32X4 {
3762         // Rule at src/isa/x64/inst.isle line 2252.
3763         let expr0_0 = SseOpcode::Movaps;
3764         return Some(expr0_0);
3765     }
3766     if pattern0_0 == F64X2 {
3767         // Rule at src/isa/x64/inst.isle line 2253.
3768         let expr0_0 = SseOpcode::Movapd;
3769         return Some(expr0_0);
3770     }
3771     if let Some((pattern1_0, pattern1_1)) = C::multi_lane(ctx, pattern0_0) {
3772         // Rule at src/isa/x64/inst.isle line 2254.
3773         let expr0_0 = SseOpcode::Movdqa;
3774         return Some(expr0_0);
3775     }
3776     return None;
3777 }
3778 
3779 // Generated as internal constructor for term x64_blend.
3780 pub fn constructor_x64_blend<C: Context>(
3781     ctx: &mut C,
3782     arg0: Type,
3783     arg1: &XmmMem,
3784     arg2: &XmmMem,
3785     arg3: Xmm,
3786 ) -> Option<Xmm> {
3787     let pattern0_0 = arg0;
3788     let pattern1_0 = arg1;
3789     let pattern2_0 = arg2;
3790     let pattern3_0 = arg3;
3791     // Rule at src/isa/x64/inst.isle line 2258.
3792     let expr0_0 = C::xmm0(ctx);
3793     let expr1_0 = constructor_sse_mov_op(ctx, pattern0_0)?;
3794     let expr2_0 = MInst::XmmUnaryRmR {
3795         op: expr1_0,
3796         src: pattern1_0.clone(),
3797         dst: expr0_0,
3798     };
3799     let expr3_0 = C::emit(ctx, &expr2_0);
3800     let expr4_0 = constructor_sse_blend_op(ctx, pattern0_0)?;
3801     let expr5_0 = constructor_xmm_rm_r(ctx, pattern0_0, &expr4_0, pattern3_0, pattern2_0)?;
3802     return Some(expr5_0);
3803 }
3804 
3805 // Generated as internal constructor for term x64_blendvpd.
3806 pub fn constructor_x64_blendvpd<C: Context>(
3807     ctx: &mut C,
3808     arg0: Xmm,
3809     arg1: &XmmMem,
3810     arg2: Xmm,
3811 ) -> Option<Xmm> {
3812     let pattern0_0 = arg0;
3813     let pattern1_0 = arg1;
3814     let pattern2_0 = arg2;
3815     // Rule at src/isa/x64/inst.isle line 2272.
3816     let expr0_0 = C::xmm0(ctx);
3817     let expr1_0 = SseOpcode::Movapd;
3818     let expr2_0 = C::xmm_to_xmm_mem(ctx, pattern2_0);
3819     let expr3_0 = MInst::XmmUnaryRmR {
3820         op: expr1_0,
3821         src: expr2_0,
3822         dst: expr0_0,
3823     };
3824     let expr4_0 = C::emit(ctx, &expr3_0);
3825     let expr5_0: Type = F64X2;
3826     let expr6_0 = SseOpcode::Blendvpd;
3827     let expr7_0 = constructor_xmm_rm_r(ctx, expr5_0, &expr6_0, pattern0_0, pattern1_0)?;
3828     return Some(expr7_0);
3829 }
3830 
3831 // Generated as internal constructor for term x64_movsd_regmove.
3832 pub fn constructor_x64_movsd_regmove<C: Context>(
3833     ctx: &mut C,
3834     arg0: Xmm,
3835     arg1: &XmmMem,
3836 ) -> Option<Xmm> {
3837     let pattern0_0 = arg0;
3838     let pattern1_0 = arg1;
3839     // Rule at src/isa/x64/inst.isle line 2286.
3840     let expr0_0: Type = I8X16;
3841     let expr1_0 = SseOpcode::Movsd;
3842     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3843     return Some(expr2_0);
3844 }
3845 
3846 // Generated as internal constructor for term x64_movlhps.
3847 pub fn constructor_x64_movlhps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3848     let pattern0_0 = arg0;
3849     let pattern1_0 = arg1;
3850     // Rule at src/isa/x64/inst.isle line 2291.
3851     let expr0_0: Type = I8X16;
3852     let expr1_0 = SseOpcode::Movlhps;
3853     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3854     return Some(expr2_0);
3855 }
3856 
3857 // Generated as internal constructor for term x64_pmaxs.
3858 pub fn constructor_x64_pmaxs<C: Context>(
3859     ctx: &mut C,
3860     arg0: Type,
3861     arg1: Xmm,
3862     arg2: &XmmMem,
3863 ) -> Option<Xmm> {
3864     let pattern0_0 = arg0;
3865     if pattern0_0 == I8X16 {
3866         let pattern2_0 = arg1;
3867         let pattern3_0 = arg2;
3868         // Rule at src/isa/x64/inst.isle line 2296.
3869         let expr0_0 = constructor_x64_pmaxsb(ctx, pattern2_0, pattern3_0)?;
3870         return Some(expr0_0);
3871     }
3872     if pattern0_0 == I16X8 {
3873         let pattern2_0 = arg1;
3874         let pattern3_0 = arg2;
3875         // Rule at src/isa/x64/inst.isle line 2297.
3876         let expr0_0 = constructor_x64_pmaxsw(ctx, pattern2_0, pattern3_0)?;
3877         return Some(expr0_0);
3878     }
3879     if pattern0_0 == I32X4 {
3880         let pattern2_0 = arg1;
3881         let pattern3_0 = arg2;
3882         // Rule at src/isa/x64/inst.isle line 2298.
3883         let expr0_0 = constructor_x64_pmaxsd(ctx, pattern2_0, pattern3_0)?;
3884         return Some(expr0_0);
3885     }
3886     return None;
3887 }
3888 
3889 // Generated as internal constructor for term x64_pmaxsb.
3890 pub fn constructor_x64_pmaxsb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3891     let pattern0_0 = arg0;
3892     let pattern1_0 = arg1;
3893     // Rule at src/isa/x64/inst.isle line 2301.
3894     let expr0_0: Type = I8X16;
3895     let expr1_0 = SseOpcode::Pmaxsb;
3896     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3897     return Some(expr2_0);
3898 }
3899 
3900 // Generated as internal constructor for term x64_pmaxsw.
3901 pub fn constructor_x64_pmaxsw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3902     let pattern0_0 = arg0;
3903     let pattern1_0 = arg1;
3904     // Rule at src/isa/x64/inst.isle line 2303.
3905     let expr0_0: Type = I8X16;
3906     let expr1_0 = SseOpcode::Pmaxsw;
3907     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3908     return Some(expr2_0);
3909 }
3910 
3911 // Generated as internal constructor for term x64_pmaxsd.
3912 pub fn constructor_x64_pmaxsd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3913     let pattern0_0 = arg0;
3914     let pattern1_0 = arg1;
3915     // Rule at src/isa/x64/inst.isle line 2305.
3916     let expr0_0: Type = I8X16;
3917     let expr1_0 = SseOpcode::Pmaxsd;
3918     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3919     return Some(expr2_0);
3920 }
3921 
3922 // Generated as internal constructor for term x64_pmins.
3923 pub fn constructor_x64_pmins<C: Context>(
3924     ctx: &mut C,
3925     arg0: Type,
3926     arg1: Xmm,
3927     arg2: &XmmMem,
3928 ) -> Option<Xmm> {
3929     let pattern0_0 = arg0;
3930     if pattern0_0 == I8X16 {
3931         let pattern2_0 = arg1;
3932         let pattern3_0 = arg2;
3933         // Rule at src/isa/x64/inst.isle line 2309.
3934         let expr0_0 = constructor_x64_pminsb(ctx, pattern2_0, pattern3_0)?;
3935         return Some(expr0_0);
3936     }
3937     if pattern0_0 == I16X8 {
3938         let pattern2_0 = arg1;
3939         let pattern3_0 = arg2;
3940         // Rule at src/isa/x64/inst.isle line 2310.
3941         let expr0_0 = constructor_x64_pminsw(ctx, pattern2_0, pattern3_0)?;
3942         return Some(expr0_0);
3943     }
3944     if pattern0_0 == I32X4 {
3945         let pattern2_0 = arg1;
3946         let pattern3_0 = arg2;
3947         // Rule at src/isa/x64/inst.isle line 2311.
3948         let expr0_0 = constructor_x64_pminsd(ctx, pattern2_0, pattern3_0)?;
3949         return Some(expr0_0);
3950     }
3951     return None;
3952 }
3953 
3954 // Generated as internal constructor for term x64_pminsb.
3955 pub fn constructor_x64_pminsb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3956     let pattern0_0 = arg0;
3957     let pattern1_0 = arg1;
3958     // Rule at src/isa/x64/inst.isle line 2314.
3959     let expr0_0: Type = I8X16;
3960     let expr1_0 = SseOpcode::Pminsb;
3961     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3962     return Some(expr2_0);
3963 }
3964 
3965 // Generated as internal constructor for term x64_pminsw.
3966 pub fn constructor_x64_pminsw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3967     let pattern0_0 = arg0;
3968     let pattern1_0 = arg1;
3969     // Rule at src/isa/x64/inst.isle line 2316.
3970     let expr0_0: Type = I16X8;
3971     let expr1_0 = SseOpcode::Pminsw;
3972     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3973     return Some(expr2_0);
3974 }
3975 
3976 // Generated as internal constructor for term x64_pminsd.
3977 pub fn constructor_x64_pminsd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
3978     let pattern0_0 = arg0;
3979     let pattern1_0 = arg1;
3980     // Rule at src/isa/x64/inst.isle line 2318.
3981     let expr0_0: Type = I32X4;
3982     let expr1_0 = SseOpcode::Pminsd;
3983     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
3984     return Some(expr2_0);
3985 }
3986 
3987 // Generated as internal constructor for term x64_pmaxu.
3988 pub fn constructor_x64_pmaxu<C: Context>(
3989     ctx: &mut C,
3990     arg0: Type,
3991     arg1: Xmm,
3992     arg2: &XmmMem,
3993 ) -> Option<Xmm> {
3994     let pattern0_0 = arg0;
3995     if pattern0_0 == I8X16 {
3996         let pattern2_0 = arg1;
3997         let pattern3_0 = arg2;
3998         // Rule at src/isa/x64/inst.isle line 2322.
3999         let expr0_0 = constructor_x64_pmaxub(ctx, pattern2_0, pattern3_0)?;
4000         return Some(expr0_0);
4001     }
4002     if pattern0_0 == I16X8 {
4003         let pattern2_0 = arg1;
4004         let pattern3_0 = arg2;
4005         // Rule at src/isa/x64/inst.isle line 2323.
4006         let expr0_0 = constructor_x64_pmaxuw(ctx, pattern2_0, pattern3_0)?;
4007         return Some(expr0_0);
4008     }
4009     if pattern0_0 == I32X4 {
4010         let pattern2_0 = arg1;
4011         let pattern3_0 = arg2;
4012         // Rule at src/isa/x64/inst.isle line 2324.
4013         let expr0_0 = constructor_x64_pmaxud(ctx, pattern2_0, pattern3_0)?;
4014         return Some(expr0_0);
4015     }
4016     return None;
4017 }
4018 
4019 // Generated as internal constructor for term x64_pmaxub.
4020 pub fn constructor_x64_pmaxub<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
4021     let pattern0_0 = arg0;
4022     let pattern1_0 = arg1;
4023     // Rule at src/isa/x64/inst.isle line 2327.
4024     let expr0_0: Type = I8X16;
4025     let expr1_0 = SseOpcode::Pmaxub;
4026     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
4027     return Some(expr2_0);
4028 }
4029 
4030 // Generated as internal constructor for term x64_pmaxuw.
4031 pub fn constructor_x64_pmaxuw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
4032     let pattern0_0 = arg0;
4033     let pattern1_0 = arg1;
4034     // Rule at src/isa/x64/inst.isle line 2329.
4035     let expr0_0: Type = I8X16;
4036     let expr1_0 = SseOpcode::Pmaxuw;
4037     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
4038     return Some(expr2_0);
4039 }
4040 
4041 // Generated as internal constructor for term x64_pmaxud.
4042 pub fn constructor_x64_pmaxud<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
4043     let pattern0_0 = arg0;
4044     let pattern1_0 = arg1;
4045     // Rule at src/isa/x64/inst.isle line 2331.
4046     let expr0_0: Type = I8X16;
4047     let expr1_0 = SseOpcode::Pmaxud;
4048     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
4049     return Some(expr2_0);
4050 }
4051 
4052 // Generated as internal constructor for term x64_pminu.
4053 pub fn constructor_x64_pminu<C: Context>(
4054     ctx: &mut C,
4055     arg0: Type,
4056     arg1: Xmm,
4057     arg2: &XmmMem,
4058 ) -> Option<Xmm> {
4059     let pattern0_0 = arg0;
4060     if pattern0_0 == I8X16 {
4061         let pattern2_0 = arg1;
4062         let pattern3_0 = arg2;
4063         // Rule at src/isa/x64/inst.isle line 2335.
4064         let expr0_0 = constructor_x64_pminub(ctx, pattern2_0, pattern3_0)?;
4065         return Some(expr0_0);
4066     }
4067     if pattern0_0 == I16X8 {
4068         let pattern2_0 = arg1;
4069         let pattern3_0 = arg2;
4070         // Rule at src/isa/x64/inst.isle line 2336.
4071         let expr0_0 = constructor_x64_pminuw(ctx, pattern2_0, pattern3_0)?;
4072         return Some(expr0_0);
4073     }
4074     if pattern0_0 == I32X4 {
4075         let pattern2_0 = arg1;
4076         let pattern3_0 = arg2;
4077         // Rule at src/isa/x64/inst.isle line 2337.
4078         let expr0_0 = constructor_x64_pminud(ctx, pattern2_0, pattern3_0)?;
4079         return Some(expr0_0);
4080     }
4081     return None;
4082 }
4083 
4084 // Generated as internal constructor for term x64_pminub.
4085 pub fn constructor_x64_pminub<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
4086     let pattern0_0 = arg0;
4087     let pattern1_0 = arg1;
4088     // Rule at src/isa/x64/inst.isle line 2340.
4089     let expr0_0: Type = I8X16;
4090     let expr1_0 = SseOpcode::Pminub;
4091     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
4092     return Some(expr2_0);
4093 }
4094 
4095 // Generated as internal constructor for term x64_pminuw.
4096 pub fn constructor_x64_pminuw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
4097     let pattern0_0 = arg0;
4098     let pattern1_0 = arg1;
4099     // Rule at src/isa/x64/inst.isle line 2342.
4100     let expr0_0: Type = I8X16;
4101     let expr1_0 = SseOpcode::Pminuw;
4102     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
4103     return Some(expr2_0);
4104 }
4105 
4106 // Generated as internal constructor for term x64_pminud.
4107 pub fn constructor_x64_pminud<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
4108     let pattern0_0 = arg0;
4109     let pattern1_0 = arg1;
4110     // Rule at src/isa/x64/inst.isle line 2344.
4111     let expr0_0: Type = I8X16;
4112     let expr1_0 = SseOpcode::Pminud;
4113     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
4114     return Some(expr2_0);
4115 }
4116 
4117 // Generated as internal constructor for term x64_punpcklbw.
4118 pub fn constructor_x64_punpcklbw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
4119     let pattern0_0 = arg0;
4120     let pattern1_0 = arg1;
4121     // Rule at src/isa/x64/inst.isle line 2348.
4122     let expr0_0: Type = I8X16;
4123     let expr1_0 = SseOpcode::Punpcklbw;
4124     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
4125     return Some(expr2_0);
4126 }
4127 
4128 // Generated as internal constructor for term x64_punpckhbw.
4129 pub fn constructor_x64_punpckhbw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
4130     let pattern0_0 = arg0;
4131     let pattern1_0 = arg1;
4132     // Rule at src/isa/x64/inst.isle line 2353.
4133     let expr0_0: Type = I8X16;
4134     let expr1_0 = SseOpcode::Punpckhbw;
4135     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
4136     return Some(expr2_0);
4137 }
4138 
4139 // Generated as internal constructor for term x64_packsswb.
4140 pub fn constructor_x64_packsswb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
4141     let pattern0_0 = arg0;
4142     let pattern1_0 = arg1;
4143     // Rule at src/isa/x64/inst.isle line 2358.
4144     let expr0_0: Type = I8X16;
4145     let expr1_0 = SseOpcode::Packsswb;
4146     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
4147     return Some(expr2_0);
4148 }
4149 
4150 // Generated as internal constructor for term xmm_rm_r_imm.
4151 pub fn constructor_xmm_rm_r_imm<C: Context>(
4152     ctx: &mut C,
4153     arg0: &SseOpcode,
4154     arg1: Reg,
4155     arg2: &RegMem,
4156     arg3: u8,
4157     arg4: &OperandSize,
4158 ) -> Option<Xmm> {
4159     let pattern0_0 = arg0;
4160     let pattern1_0 = arg1;
4161     let pattern2_0 = arg2;
4162     let pattern3_0 = arg3;
4163     let pattern4_0 = arg4;
4164     // Rule at src/isa/x64/inst.isle line 2363.
4165     let expr0_0 = C::temp_writable_xmm(ctx);
4166     let expr1_0 = C::writable_xmm_to_reg(ctx, expr0_0);
4167     let expr2_0 = MInst::XmmRmRImm {
4168         op: pattern0_0.clone(),
4169         src1: pattern1_0,
4170         src2: pattern2_0.clone(),
4171         dst: expr1_0,
4172         imm: pattern3_0,
4173         size: pattern4_0.clone(),
4174     };
4175     let expr3_0 = C::emit(ctx, &expr2_0);
4176     let expr4_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
4177     return Some(expr4_0);
4178 }
4179 
4180 // Generated as internal constructor for term x64_palignr.
4181 pub fn constructor_x64_palignr<C: Context>(
4182     ctx: &mut C,
4183     arg0: Xmm,
4184     arg1: &XmmMem,
4185     arg2: u8,
4186     arg3: &OperandSize,
4187 ) -> Option<Xmm> {
4188     let pattern0_0 = arg0;
4189     let pattern1_0 = arg1;
4190     let pattern2_0 = arg2;
4191     let pattern3_0 = arg3;
4192     // Rule at src/isa/x64/inst.isle line 2375.
4193     let expr0_0 = SseOpcode::Palignr;
4194     let expr1_0 = C::xmm_to_reg(ctx, pattern0_0);
4195     let expr2_0 = C::xmm_mem_to_reg_mem(ctx, pattern1_0);
4196     let expr3_0 =
4197         constructor_xmm_rm_r_imm(ctx, &expr0_0, expr1_0, &expr2_0, pattern2_0, pattern3_0)?;
4198     return Some(expr3_0);
4199 }
4200 
4201 // Generated as internal constructor for term x64_cmpp.
4202 pub fn constructor_x64_cmpp<C: Context>(
4203     ctx: &mut C,
4204     arg0: Type,
4205     arg1: Xmm,
4206     arg2: &XmmMem,
4207     arg3: &FcmpImm,
4208 ) -> Option<Xmm> {
4209     let pattern0_0 = arg0;
4210     if pattern0_0 == F32X4 {
4211         let pattern2_0 = arg1;
4212         let pattern3_0 = arg2;
4213         let pattern4_0 = arg3;
4214         // Rule at src/isa/x64/inst.isle line 2384.
4215         let expr0_0 = constructor_x64_cmpps(ctx, pattern2_0, pattern3_0, pattern4_0)?;
4216         return Some(expr0_0);
4217     }
4218     if pattern0_0 == F64X2 {
4219         let pattern2_0 = arg1;
4220         let pattern3_0 = arg2;
4221         let pattern4_0 = arg3;
4222         // Rule at src/isa/x64/inst.isle line 2385.
4223         let expr0_0 = constructor_x64_cmppd(ctx, pattern2_0, pattern3_0, pattern4_0)?;
4224         return Some(expr0_0);
4225     }
4226     return None;
4227 }
4228 
4229 // Generated as internal constructor for term x64_cmpps.
4230 pub fn constructor_x64_cmpps<C: Context>(
4231     ctx: &mut C,
4232     arg0: Xmm,
4233     arg1: &XmmMem,
4234     arg2: &FcmpImm,
4235 ) -> Option<Xmm> {
4236     let pattern0_0 = arg0;
4237     let pattern1_0 = arg1;
4238     let pattern2_0 = arg2;
4239     // Rule at src/isa/x64/inst.isle line 2388.
4240     let expr0_0 = SseOpcode::Cmpps;
4241     let expr1_0 = C::xmm_to_reg(ctx, pattern0_0);
4242     let expr2_0 = C::xmm_mem_to_reg_mem(ctx, pattern1_0);
4243     let expr3_0 = C::encode_fcmp_imm(ctx, pattern2_0);
4244     let expr4_0 = OperandSize::Size32;
4245     let expr5_0 = constructor_xmm_rm_r_imm(ctx, &expr0_0, expr1_0, &expr2_0, expr3_0, &expr4_0)?;
4246     return Some(expr5_0);
4247 }
4248 
4249 // Generated as internal constructor for term x64_cmppd.
4250 pub fn constructor_x64_cmppd<C: Context>(
4251     ctx: &mut C,
4252     arg0: Xmm,
4253     arg1: &XmmMem,
4254     arg2: &FcmpImm,
4255 ) -> Option<Xmm> {
4256     let pattern0_0 = arg0;
4257     let pattern1_0 = arg1;
4258     let pattern2_0 = arg2;
4259     // Rule at src/isa/x64/inst.isle line 2399.
4260     let expr0_0 = SseOpcode::Cmppd;
4261     let expr1_0 = C::xmm_to_reg(ctx, pattern0_0);
4262     let expr2_0 = C::xmm_mem_to_reg_mem(ctx, pattern1_0);
4263     let expr3_0 = C::encode_fcmp_imm(ctx, pattern2_0);
4264     let expr4_0 = OperandSize::Size32;
4265     let expr5_0 = constructor_xmm_rm_r_imm(ctx, &expr0_0, expr1_0, &expr2_0, expr3_0, &expr4_0)?;
4266     return Some(expr5_0);
4267 }
4268 
4269 // Generated as internal constructor for term x64_pinsrb.
4270 pub fn constructor_x64_pinsrb<C: Context>(
4271     ctx: &mut C,
4272     arg0: Xmm,
4273     arg1: &GprMem,
4274     arg2: u8,
4275 ) -> Option<Xmm> {
4276     let pattern0_0 = arg0;
4277     let pattern1_0 = arg1;
4278     let pattern2_0 = arg2;
4279     // Rule at src/isa/x64/inst.isle line 2408.
4280     let expr0_0 = SseOpcode::Pinsrb;
4281     let expr1_0 = C::xmm_to_reg(ctx, pattern0_0);
4282     let expr2_0 = C::gpr_mem_to_reg_mem(ctx, pattern1_0);
4283     let expr3_0 = OperandSize::Size32;
4284     let expr4_0 = constructor_xmm_rm_r_imm(ctx, &expr0_0, expr1_0, &expr2_0, pattern2_0, &expr3_0)?;
4285     return Some(expr4_0);
4286 }
4287 
4288 // Generated as internal constructor for term x64_pinsrw.
4289 pub fn constructor_x64_pinsrw<C: Context>(
4290     ctx: &mut C,
4291     arg0: Xmm,
4292     arg1: &GprMem,
4293     arg2: u8,
4294 ) -> Option<Xmm> {
4295     let pattern0_0 = arg0;
4296     let pattern1_0 = arg1;
4297     let pattern2_0 = arg2;
4298     // Rule at src/isa/x64/inst.isle line 2417.
4299     let expr0_0 = SseOpcode::Pinsrw;
4300     let expr1_0 = C::xmm_to_reg(ctx, pattern0_0);
4301     let expr2_0 = C::gpr_mem_to_reg_mem(ctx, pattern1_0);
4302     let expr3_0 = OperandSize::Size32;
4303     let expr4_0 = constructor_xmm_rm_r_imm(ctx, &expr0_0, expr1_0, &expr2_0, pattern2_0, &expr3_0)?;
4304     return Some(expr4_0);
4305 }
4306 
4307 // Generated as internal constructor for term x64_pinsrd.
4308 pub fn constructor_x64_pinsrd<C: Context>(
4309     ctx: &mut C,
4310     arg0: Xmm,
4311     arg1: &GprMem,
4312     arg2: u8,
4313     arg3: &OperandSize,
4314 ) -> Option<Xmm> {
4315     let pattern0_0 = arg0;
4316     let pattern1_0 = arg1;
4317     let pattern2_0 = arg2;
4318     let pattern3_0 = arg3;
4319     // Rule at src/isa/x64/inst.isle line 2426.
4320     let expr0_0 = SseOpcode::Pinsrd;
4321     let expr1_0 = C::xmm_to_reg(ctx, pattern0_0);
4322     let expr2_0 = C::gpr_mem_to_reg_mem(ctx, pattern1_0);
4323     let expr3_0 =
4324         constructor_xmm_rm_r_imm(ctx, &expr0_0, expr1_0, &expr2_0, pattern2_0, pattern3_0)?;
4325     return Some(expr3_0);
4326 }
4327 
4328 // Generated as internal constructor for term x64_pmaddwd.
4329 pub fn constructor_x64_pmaddwd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
4330     let pattern0_0 = arg0;
4331     let pattern1_0 = arg1;
4332     // Rule at src/isa/x64/inst.isle line 2435.
4333     let expr0_0 = C::temp_writable_xmm(ctx);
4334     let expr1_0 = SseOpcode::Pmaddwd;
4335     let expr2_0 = MInst::XmmRmR {
4336         op: expr1_0,
4337         src1: pattern0_0,
4338         src2: pattern1_0.clone(),
4339         dst: expr0_0,
4340     };
4341     let expr3_0 = C::emit(ctx, &expr2_0);
4342     let expr4_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
4343     return Some(expr4_0);
4344 }
4345 
4346 // Generated as internal constructor for term x64_insertps.
4347 pub fn constructor_x64_insertps<C: Context>(
4348     ctx: &mut C,
4349     arg0: Xmm,
4350     arg1: &XmmMem,
4351     arg2: u8,
4352 ) -> Option<Xmm> {
4353     let pattern0_0 = arg0;
4354     let pattern1_0 = arg1;
4355     let pattern2_0 = arg2;
4356     // Rule at src/isa/x64/inst.isle line 2445.
4357     let expr0_0 = SseOpcode::Insertps;
4358     let expr1_0 = C::xmm_to_reg(ctx, pattern0_0);
4359     let expr2_0 = C::xmm_mem_to_reg_mem(ctx, pattern1_0);
4360     let expr3_0 = OperandSize::Size32;
4361     let expr4_0 = constructor_xmm_rm_r_imm(ctx, &expr0_0, expr1_0, &expr2_0, pattern2_0, &expr3_0)?;
4362     return Some(expr4_0);
4363 }
4364 
4365 // Generated as internal constructor for term x64_pshufd.
4366 pub fn constructor_x64_pshufd<C: Context>(
4367     ctx: &mut C,
4368     arg0: &XmmMem,
4369     arg1: u8,
4370     arg2: &OperandSize,
4371 ) -> Option<Xmm> {
4372     let pattern0_0 = arg0;
4373     let pattern1_0 = arg1;
4374     let pattern2_0 = arg2;
4375     // Rule at src/isa/x64/inst.isle line 2454.
4376     let expr0_0 = C::temp_writable_xmm(ctx);
4377     let expr1_0 = SseOpcode::Pshufd;
4378     let expr2_0 = constructor_writable_xmm_to_r_reg(ctx, expr0_0)?;
4379     let expr3_0 = C::xmm_mem_to_reg_mem(ctx, pattern0_0);
4380     let expr4_0 = C::writable_xmm_to_reg(ctx, expr0_0);
4381     let expr5_0 = MInst::XmmRmRImm {
4382         op: expr1_0,
4383         src1: expr2_0,
4384         src2: expr3_0,
4385         dst: expr4_0,
4386         imm: pattern1_0,
4387         size: pattern2_0.clone(),
4388     };
4389     let expr6_0 = C::emit(ctx, &expr5_0);
4390     let expr7_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
4391     return Some(expr7_0);
4392 }
4393 
4394 // Generated as internal constructor for term x64_pshufb.
4395 pub fn constructor_x64_pshufb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
4396     let pattern0_0 = arg0;
4397     let pattern1_0 = arg1;
4398     // Rule at src/isa/x64/inst.isle line 2466.
4399     let expr0_0 = C::temp_writable_xmm(ctx);
4400     let expr1_0 = SseOpcode::Pshufb;
4401     let expr2_0 = MInst::XmmRmR {
4402         op: expr1_0,
4403         src1: pattern0_0,
4404         src2: pattern1_0.clone(),
4405         dst: expr0_0,
4406     };
4407     let expr3_0 = C::emit(ctx, &expr2_0);
4408     let expr4_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
4409     return Some(expr4_0);
4410 }
4411 
4412 // Generated as internal constructor for term xmm_unary_rm_r.
4413 pub fn constructor_xmm_unary_rm_r<C: Context>(
4414     ctx: &mut C,
4415     arg0: &SseOpcode,
4416     arg1: &XmmMem,
4417 ) -> Option<Xmm> {
4418     let pattern0_0 = arg0;
4419     let pattern1_0 = arg1;
4420     // Rule at src/isa/x64/inst.isle line 2476.
4421     let expr0_0 = C::temp_writable_xmm(ctx);
4422     let expr1_0 = MInst::XmmUnaryRmR {
4423         op: pattern0_0.clone(),
4424         src: pattern1_0.clone(),
4425         dst: expr0_0,
4426     };
4427     let expr2_0 = C::emit(ctx, &expr1_0);
4428     let expr3_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
4429     return Some(expr3_0);
4430 }
4431 
4432 // Generated as internal constructor for term x64_pabsb.
4433 pub fn constructor_x64_pabsb<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Option<Xmm> {
4434     let pattern0_0 = arg0;
4435     // Rule at src/isa/x64/inst.isle line 2483.
4436     let expr0_0 = SseOpcode::Pabsb;
4437     let expr1_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, pattern0_0)?;
4438     return Some(expr1_0);
4439 }
4440 
4441 // Generated as internal constructor for term x64_pabsw.
4442 pub fn constructor_x64_pabsw<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Option<Xmm> {
4443     let pattern0_0 = arg0;
4444     // Rule at src/isa/x64/inst.isle line 2488.
4445     let expr0_0 = SseOpcode::Pabsw;
4446     let expr1_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, pattern0_0)?;
4447     return Some(expr1_0);
4448 }
4449 
4450 // Generated as internal constructor for term x64_pabsd.
4451 pub fn constructor_x64_pabsd<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Option<Xmm> {
4452     let pattern0_0 = arg0;
4453     // Rule at src/isa/x64/inst.isle line 2493.
4454     let expr0_0 = SseOpcode::Pabsd;
4455     let expr1_0 = constructor_xmm_unary_rm_r(ctx, &expr0_0, pattern0_0)?;
4456     return Some(expr1_0);
4457 }
4458 
4459 // Generated as internal constructor for term xmm_unary_rm_r_evex.
4460 pub fn constructor_xmm_unary_rm_r_evex<C: Context>(
4461     ctx: &mut C,
4462     arg0: &Avx512Opcode,
4463     arg1: &XmmMem,
4464 ) -> Option<Xmm> {
4465     let pattern0_0 = arg0;
4466     let pattern1_0 = arg1;
4467     // Rule at src/isa/x64/inst.isle line 2498.
4468     let expr0_0 = C::temp_writable_xmm(ctx);
4469     let expr1_0 = MInst::XmmUnaryRmREvex {
4470         op: pattern0_0.clone(),
4471         src: pattern1_0.clone(),
4472         dst: expr0_0,
4473     };
4474     let expr2_0 = C::emit(ctx, &expr1_0);
4475     let expr3_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
4476     return Some(expr3_0);
4477 }
4478 
4479 // Generated as internal constructor for term x64_vpabsq.
4480 pub fn constructor_x64_vpabsq<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Option<Xmm> {
4481     let pattern0_0 = arg0;
4482     // Rule at src/isa/x64/inst.isle line 2505.
4483     let expr0_0 = Avx512Opcode::Vpabsq;
4484     let expr1_0 = constructor_xmm_unary_rm_r_evex(ctx, &expr0_0, pattern0_0)?;
4485     return Some(expr1_0);
4486 }
4487 
4488 // Generated as internal constructor for term x64_vpopcntb.
4489 pub fn constructor_x64_vpopcntb<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Option<Xmm> {
4490     let pattern0_0 = arg0;
4491     // Rule at src/isa/x64/inst.isle line 2510.
4492     let expr0_0 = Avx512Opcode::Vpopcntb;
4493     let expr1_0 = constructor_xmm_unary_rm_r_evex(ctx, &expr0_0, pattern0_0)?;
4494     return Some(expr1_0);
4495 }
4496 
4497 // Generated as internal constructor for term xmm_rm_r_evex.
4498 pub fn constructor_xmm_rm_r_evex<C: Context>(
4499     ctx: &mut C,
4500     arg0: &Avx512Opcode,
4501     arg1: &XmmMem,
4502     arg2: Xmm,
4503 ) -> Option<Xmm> {
4504     let pattern0_0 = arg0;
4505     let pattern1_0 = arg1;
4506     let pattern2_0 = arg2;
4507     // Rule at src/isa/x64/inst.isle line 2515.
4508     let expr0_0 = C::temp_writable_xmm(ctx);
4509     let expr1_0 = MInst::XmmRmREvex {
4510         op: pattern0_0.clone(),
4511         src1: pattern1_0.clone(),
4512         src2: pattern2_0,
4513         dst: expr0_0,
4514     };
4515     let expr2_0 = C::emit(ctx, &expr1_0);
4516     let expr3_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
4517     return Some(expr3_0);
4518 }
4519 
4520 // Generated as internal constructor for term x64_vpmullq.
4521 pub fn constructor_x64_vpmullq<C: Context>(ctx: &mut C, arg0: &XmmMem, arg1: Xmm) -> Option<Xmm> {
4522     let pattern0_0 = arg0;
4523     let pattern1_0 = arg1;
4524     // Rule at src/isa/x64/inst.isle line 2527.
4525     let expr0_0 = Avx512Opcode::Vpmullq;
4526     let expr1_0 = constructor_xmm_rm_r_evex(ctx, &expr0_0, pattern0_0, pattern1_0)?;
4527     return Some(expr1_0);
4528 }
4529 
4530 // Generated as internal constructor for term mul_hi.
4531 pub fn constructor_mul_hi<C: Context>(
4532     ctx: &mut C,
4533     arg0: Type,
4534     arg1: bool,
4535     arg2: Gpr,
4536     arg3: &GprMem,
4537 ) -> Option<ValueRegs> {
4538     let pattern0_0 = arg0;
4539     let pattern1_0 = arg1;
4540     let pattern2_0 = arg2;
4541     let pattern3_0 = arg3;
4542     // Rule at src/isa/x64/inst.isle line 2536.
4543     let expr0_0 = C::temp_writable_gpr(ctx);
4544     let expr1_0 = C::temp_writable_gpr(ctx);
4545     let expr2_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
4546     let expr3_0 = MInst::MulHi {
4547         size: expr2_0,
4548         signed: pattern1_0,
4549         src1: pattern2_0,
4550         src2: pattern3_0.clone(),
4551         dst_lo: expr0_0,
4552         dst_hi: expr1_0,
4553     };
4554     let expr4_0 = C::emit(ctx, &expr3_0);
4555     let expr5_0 = C::writable_gpr_to_gpr(ctx, expr0_0);
4556     let expr6_0 = C::writable_gpr_to_gpr(ctx, expr1_0);
4557     let expr7_0 = constructor_value_gprs(ctx, expr5_0, expr6_0)?;
4558     return Some(expr7_0);
4559 }
4560 
4561 // Generated as internal constructor for term mulhi_u.
4562 pub fn constructor_mulhi_u<C: Context>(
4563     ctx: &mut C,
4564     arg0: Type,
4565     arg1: Gpr,
4566     arg2: &GprMem,
4567 ) -> Option<ValueRegs> {
4568     let pattern0_0 = arg0;
4569     let pattern1_0 = arg1;
4570     let pattern2_0 = arg2;
4571     // Rule at src/isa/x64/inst.isle line 2551.
4572     let expr0_0: bool = false;
4573     let expr1_0 = constructor_mul_hi(ctx, pattern0_0, expr0_0, pattern1_0, pattern2_0)?;
4574     return Some(expr1_0);
4575 }
4576 
4577 // Generated as internal constructor for term xmm_rmi_xmm.
4578 pub fn constructor_xmm_rmi_xmm<C: Context>(
4579     ctx: &mut C,
4580     arg0: &SseOpcode,
4581     arg1: Xmm,
4582     arg2: &XmmMemImm,
4583 ) -> Option<Xmm> {
4584     let pattern0_0 = arg0;
4585     let pattern1_0 = arg1;
4586     let pattern2_0 = arg2;
4587     // Rule at src/isa/x64/inst.isle line 2556.
4588     let expr0_0 = C::temp_writable_xmm(ctx);
4589     let expr1_0 = MInst::XmmRmiReg {
4590         opcode: pattern0_0.clone(),
4591         src1: pattern1_0,
4592         src2: pattern2_0.clone(),
4593         dst: expr0_0,
4594     };
4595     let expr2_0 = C::emit(ctx, &expr1_0);
4596     let expr3_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
4597     return Some(expr3_0);
4598 }
4599 
4600 // Generated as internal constructor for term x64_psllw.
4601 pub fn constructor_x64_psllw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMemImm) -> Option<Xmm> {
4602     let pattern0_0 = arg0;
4603     let pattern1_0 = arg1;
4604     // Rule at src/isa/x64/inst.isle line 2566.
4605     let expr0_0 = SseOpcode::Psllw;
4606     let expr1_0 = constructor_xmm_rmi_xmm(ctx, &expr0_0, pattern0_0, pattern1_0)?;
4607     return Some(expr1_0);
4608 }
4609 
4610 // Generated as internal constructor for term x64_pslld.
4611 pub fn constructor_x64_pslld<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMemImm) -> Option<Xmm> {
4612     let pattern0_0 = arg0;
4613     let pattern1_0 = arg1;
4614     // Rule at src/isa/x64/inst.isle line 2571.
4615     let expr0_0 = SseOpcode::Pslld;
4616     let expr1_0 = constructor_xmm_rmi_xmm(ctx, &expr0_0, pattern0_0, pattern1_0)?;
4617     return Some(expr1_0);
4618 }
4619 
4620 // Generated as internal constructor for term x64_psllq.
4621 pub fn constructor_x64_psllq<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMemImm) -> Option<Xmm> {
4622     let pattern0_0 = arg0;
4623     let pattern1_0 = arg1;
4624     // Rule at src/isa/x64/inst.isle line 2576.
4625     let expr0_0 = SseOpcode::Psllq;
4626     let expr1_0 = constructor_xmm_rmi_xmm(ctx, &expr0_0, pattern0_0, pattern1_0)?;
4627     return Some(expr1_0);
4628 }
4629 
4630 // Generated as internal constructor for term x64_psrlw.
4631 pub fn constructor_x64_psrlw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMemImm) -> Option<Xmm> {
4632     let pattern0_0 = arg0;
4633     let pattern1_0 = arg1;
4634     // Rule at src/isa/x64/inst.isle line 2581.
4635     let expr0_0 = SseOpcode::Psrlw;
4636     let expr1_0 = constructor_xmm_rmi_xmm(ctx, &expr0_0, pattern0_0, pattern1_0)?;
4637     return Some(expr1_0);
4638 }
4639 
4640 // Generated as internal constructor for term x64_psrld.
4641 pub fn constructor_x64_psrld<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMemImm) -> Option<Xmm> {
4642     let pattern0_0 = arg0;
4643     let pattern1_0 = arg1;
4644     // Rule at src/isa/x64/inst.isle line 2586.
4645     let expr0_0 = SseOpcode::Psrld;
4646     let expr1_0 = constructor_xmm_rmi_xmm(ctx, &expr0_0, pattern0_0, pattern1_0)?;
4647     return Some(expr1_0);
4648 }
4649 
4650 // Generated as internal constructor for term x64_psrlq.
4651 pub fn constructor_x64_psrlq<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMemImm) -> Option<Xmm> {
4652     let pattern0_0 = arg0;
4653     let pattern1_0 = arg1;
4654     // Rule at src/isa/x64/inst.isle line 2591.
4655     let expr0_0 = SseOpcode::Psrlq;
4656     let expr1_0 = constructor_xmm_rmi_xmm(ctx, &expr0_0, pattern0_0, pattern1_0)?;
4657     return Some(expr1_0);
4658 }
4659 
4660 // Generated as internal constructor for term x64_psraw.
4661 pub fn constructor_x64_psraw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMemImm) -> Option<Xmm> {
4662     let pattern0_0 = arg0;
4663     let pattern1_0 = arg1;
4664     // Rule at src/isa/x64/inst.isle line 2596.
4665     let expr0_0 = SseOpcode::Psraw;
4666     let expr1_0 = constructor_xmm_rmi_xmm(ctx, &expr0_0, pattern0_0, pattern1_0)?;
4667     return Some(expr1_0);
4668 }
4669 
4670 // Generated as internal constructor for term x64_psrad.
4671 pub fn constructor_x64_psrad<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMemImm) -> Option<Xmm> {
4672     let pattern0_0 = arg0;
4673     let pattern1_0 = arg1;
4674     // Rule at src/isa/x64/inst.isle line 2601.
4675     let expr0_0 = SseOpcode::Psrad;
4676     let expr1_0 = constructor_xmm_rmi_xmm(ctx, &expr0_0, pattern0_0, pattern1_0)?;
4677     return Some(expr1_0);
4678 }
4679 
4680 // Generated as internal constructor for term x64_pextrd.
4681 pub fn constructor_x64_pextrd<C: Context>(
4682     ctx: &mut C,
4683     arg0: Type,
4684     arg1: Xmm,
4685     arg2: u8,
4686 ) -> Option<Gpr> {
4687     let pattern0_0 = arg0;
4688     let pattern1_0 = arg1;
4689     let pattern2_0 = arg2;
4690     // Rule at src/isa/x64/inst.isle line 2606.
4691     let expr0_0 = C::temp_writable_gpr(ctx);
4692     let expr1_0 = SseOpcode::Pextrd;
4693     let expr2_0 = constructor_writable_gpr_to_r_reg(ctx, expr0_0)?;
4694     let expr3_0 = C::xmm_to_reg(ctx, pattern1_0);
4695     let expr4_0 = constructor_xmm_to_reg_mem(ctx, expr3_0)?;
4696     let expr5_0 = C::xmm_mem_to_reg_mem(ctx, &expr4_0);
4697     let expr6_0 = C::writable_gpr_to_reg(ctx, expr0_0);
4698     let expr7_0 = C::lane_type(ctx, pattern0_0);
4699     let expr8_0 = C::operand_size_of_type_32_64(ctx, expr7_0);
4700     let expr9_0 = MInst::XmmRmRImm {
4701         op: expr1_0,
4702         src1: expr2_0,
4703         src2: expr5_0,
4704         dst: expr6_0,
4705         imm: pattern2_0,
4706         size: expr8_0,
4707     };
4708     let expr10_0 = C::emit(ctx, &expr9_0);
4709     let expr11_0 = C::writable_gpr_to_gpr(ctx, expr0_0);
4710     return Some(expr11_0);
4711 }
4712 
4713 // Generated as internal constructor for term gpr_to_xmm.
4714 pub fn constructor_gpr_to_xmm<C: Context>(
4715     ctx: &mut C,
4716     arg0: &SseOpcode,
4717     arg1: &GprMem,
4718     arg2: &OperandSize,
4719 ) -> Option<Xmm> {
4720     let pattern0_0 = arg0;
4721     let pattern1_0 = arg1;
4722     let pattern2_0 = arg2;
4723     // Rule at src/isa/x64/inst.isle line 2618.
4724     let expr0_0 = C::temp_writable_xmm(ctx);
4725     let expr1_0 = MInst::GprToXmm {
4726         op: pattern0_0.clone(),
4727         src: pattern1_0.clone(),
4728         dst: expr0_0,
4729         src_size: pattern2_0.clone(),
4730     };
4731     let expr2_0 = C::emit(ctx, &expr1_0);
4732     let expr3_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
4733     return Some(expr3_0);
4734 }
4735 
4736 // Generated as internal constructor for term x64_not.
4737 pub fn constructor_x64_not<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Option<Gpr> {
4738     let pattern0_0 = arg0;
4739     let pattern1_0 = arg1;
4740     // Rule at src/isa/x64/inst.isle line 2625.
4741     let expr0_0 = C::temp_writable_gpr(ctx);
4742     let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
4743     let expr2_0 = MInst::Not {
4744         size: expr1_0,
4745         src: pattern1_0,
4746         dst: expr0_0,
4747     };
4748     let expr3_0 = C::emit(ctx, &expr2_0);
4749     let expr4_0 = C::writable_gpr_to_gpr(ctx, expr0_0);
4750     return Some(expr4_0);
4751 }
4752 
4753 // Generated as internal constructor for term x64_neg.
4754 pub fn constructor_x64_neg<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Option<Gpr> {
4755     let pattern0_0 = arg0;
4756     let pattern1_0 = arg1;
4757     // Rule at src/isa/x64/inst.isle line 2633.
4758     let expr0_0 = C::temp_writable_gpr(ctx);
4759     let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
4760     let expr2_0 = MInst::Neg {
4761         size: expr1_0,
4762         src: pattern1_0,
4763         dst: expr0_0,
4764     };
4765     let expr3_0 = C::emit(ctx, &expr2_0);
4766     let expr4_0 = C::writable_gpr_to_gpr(ctx, expr0_0);
4767     return Some(expr4_0);
4768 }
4769 
4770 // Generated as internal constructor for term x64_lea.
4771 pub fn constructor_x64_lea<C: Context>(ctx: &mut C, arg0: &SyntheticAmode) -> Option<Gpr> {
4772     let pattern0_0 = arg0;
4773     // Rule at src/isa/x64/inst.isle line 2640.
4774     let expr0_0 = C::temp_writable_gpr(ctx);
4775     let expr1_0 = MInst::LoadEffectiveAddress {
4776         addr: pattern0_0.clone(),
4777         dst: expr0_0,
4778     };
4779     let expr2_0 = C::emit(ctx, &expr1_0);
4780     let expr3_0 = C::writable_gpr_to_gpr(ctx, expr0_0);
4781     return Some(expr3_0);
4782 }
4783 
4784 // Generated as internal constructor for term x64_ud2.
4785 pub fn constructor_x64_ud2<C: Context>(ctx: &mut C, arg0: &TrapCode) -> Option<SideEffectNoResult> {
4786     let pattern0_0 = arg0;
4787     // Rule at src/isa/x64/inst.isle line 2647.
4788     let expr0_0 = MInst::Ud2 {
4789         trap_code: pattern0_0.clone(),
4790     };
4791     let expr1_0 = SideEffectNoResult::Inst { inst: expr0_0 };
4792     return Some(expr1_0);
4793 }
4794 
4795 // Generated as internal constructor for term x64_hlt.
4796 pub fn constructor_x64_hlt<C: Context>(ctx: &mut C) -> Option<SideEffectNoResult> {
4797     // Rule at src/isa/x64/inst.isle line 2652.
4798     let expr0_0 = MInst::Hlt;
4799     let expr1_0 = SideEffectNoResult::Inst { inst: expr0_0 };
4800     return Some(expr1_0);
4801 }
4802 
4803 // Generated as internal constructor for term x64_lzcnt.
4804 pub fn constructor_x64_lzcnt<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Option<Gpr> {
4805     let pattern0_0 = arg0;
4806     let pattern1_0 = arg1;
4807     // Rule at src/isa/x64/inst.isle line 2657.
4808     let expr0_0 = C::temp_writable_gpr(ctx);
4809     let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
4810     let expr2_0 = UnaryRmROpcode::Lzcnt;
4811     let expr3_0 = C::gpr_to_gpr_mem(ctx, pattern1_0);
4812     let expr4_0 = MInst::UnaryRmR {
4813         size: expr1_0,
4814         op: expr2_0,
4815         src: expr3_0,
4816         dst: expr0_0,
4817     };
4818     let expr5_0 = C::emit(ctx, &expr4_0);
4819     let expr6_0 = C::writable_gpr_to_gpr(ctx, expr0_0);
4820     return Some(expr6_0);
4821 }
4822 
4823 // Generated as internal constructor for term x64_tzcnt.
4824 pub fn constructor_x64_tzcnt<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Option<Gpr> {
4825     let pattern0_0 = arg0;
4826     let pattern1_0 = arg1;
4827     // Rule at src/isa/x64/inst.isle line 2665.
4828     let expr0_0 = C::temp_writable_gpr(ctx);
4829     let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
4830     let expr2_0 = UnaryRmROpcode::Tzcnt;
4831     let expr3_0 = C::gpr_to_gpr_mem(ctx, pattern1_0);
4832     let expr4_0 = MInst::UnaryRmR {
4833         size: expr1_0,
4834         op: expr2_0,
4835         src: expr3_0,
4836         dst: expr0_0,
4837     };
4838     let expr5_0 = C::emit(ctx, &expr4_0);
4839     let expr6_0 = C::writable_gpr_to_gpr(ctx, expr0_0);
4840     return Some(expr6_0);
4841 }
4842 
4843 // Generated as internal constructor for term x64_bsr.
4844 pub fn constructor_x64_bsr<C: Context>(
4845     ctx: &mut C,
4846     arg0: Type,
4847     arg1: Gpr,
4848 ) -> Option<ProducesFlags> {
4849     let pattern0_0 = arg0;
4850     let pattern1_0 = arg1;
4851     // Rule at src/isa/x64/inst.isle line 2673.
4852     let expr0_0 = C::temp_writable_gpr(ctx);
4853     let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
4854     let expr2_0 = UnaryRmROpcode::Bsr;
4855     let expr3_0 = C::gpr_to_gpr_mem(ctx, pattern1_0);
4856     let expr4_0 = MInst::UnaryRmR {
4857         size: expr1_0,
4858         op: expr2_0,
4859         src: expr3_0,
4860         dst: expr0_0,
4861     };
4862     let expr5_0 = constructor_writable_gpr_to_r_reg(ctx, expr0_0)?;
4863     let expr6_0 = ProducesFlags::ProducesFlagsReturnsReg {
4864         inst: expr4_0,
4865         result: expr5_0,
4866     };
4867     return Some(expr6_0);
4868 }
4869 
4870 // Generated as internal constructor for term bsr_or_else.
4871 pub fn constructor_bsr_or_else<C: Context>(
4872     ctx: &mut C,
4873     arg0: Type,
4874     arg1: Gpr,
4875     arg2: Gpr,
4876 ) -> Option<Gpr> {
4877     let pattern0_0 = arg0;
4878     let pattern1_0 = arg1;
4879     let pattern2_0 = arg2;
4880     // Rule at src/isa/x64/inst.isle line 2682.
4881     let expr0_0 = constructor_x64_bsr(ctx, pattern0_0, pattern1_0)?;
4882     let expr1_0 = constructor_produces_flags_get_reg(ctx, &expr0_0)?;
4883     let expr2_0 = C::gpr_new(ctx, expr1_0);
4884     let expr3_0 = CC::Z;
4885     let expr4_0 = C::gpr_to_gpr_mem(ctx, pattern2_0);
4886     let expr5_0 = constructor_cmove(ctx, pattern0_0, &expr3_0, &expr4_0, expr2_0)?;
4887     let expr6_0 = constructor_produces_flags_ignore(ctx, &expr0_0)?;
4888     let expr7_0 = constructor_with_flags_reg(ctx, &expr6_0, &expr5_0)?;
4889     let expr8_0 = C::gpr_new(ctx, expr7_0);
4890     return Some(expr8_0);
4891 }
4892 
4893 // Generated as internal constructor for term x64_bsf.
4894 pub fn constructor_x64_bsf<C: Context>(
4895     ctx: &mut C,
4896     arg0: Type,
4897     arg1: Gpr,
4898 ) -> Option<ProducesFlags> {
4899     let pattern0_0 = arg0;
4900     let pattern1_0 = arg1;
4901     // Rule at src/isa/x64/inst.isle line 2693.
4902     let expr0_0 = C::temp_writable_gpr(ctx);
4903     let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
4904     let expr2_0 = UnaryRmROpcode::Bsf;
4905     let expr3_0 = C::gpr_to_gpr_mem(ctx, pattern1_0);
4906     let expr4_0 = MInst::UnaryRmR {
4907         size: expr1_0,
4908         op: expr2_0,
4909         src: expr3_0,
4910         dst: expr0_0,
4911     };
4912     let expr5_0 = constructor_writable_gpr_to_r_reg(ctx, expr0_0)?;
4913     let expr6_0 = ProducesFlags::ProducesFlagsReturnsReg {
4914         inst: expr4_0,
4915         result: expr5_0,
4916     };
4917     return Some(expr6_0);
4918 }
4919 
4920 // Generated as internal constructor for term bsf_or_else.
4921 pub fn constructor_bsf_or_else<C: Context>(
4922     ctx: &mut C,
4923     arg0: Type,
4924     arg1: Gpr,
4925     arg2: Gpr,
4926 ) -> Option<Gpr> {
4927     let pattern0_0 = arg0;
4928     let pattern1_0 = arg1;
4929     let pattern2_0 = arg2;
4930     // Rule at src/isa/x64/inst.isle line 2702.
4931     let expr0_0 = constructor_x64_bsf(ctx, pattern0_0, pattern1_0)?;
4932     let expr1_0 = constructor_produces_flags_get_reg(ctx, &expr0_0)?;
4933     let expr2_0 = C::gpr_new(ctx, expr1_0);
4934     let expr3_0 = CC::Z;
4935     let expr4_0 = C::gpr_to_gpr_mem(ctx, pattern2_0);
4936     let expr5_0 = constructor_cmove(ctx, pattern0_0, &expr3_0, &expr4_0, expr2_0)?;
4937     let expr6_0 = constructor_produces_flags_ignore(ctx, &expr0_0)?;
4938     let expr7_0 = constructor_with_flags_reg(ctx, &expr6_0, &expr5_0)?;
4939     let expr8_0 = C::gpr_new(ctx, expr7_0);
4940     return Some(expr8_0);
4941 }
4942 
4943 // Generated as internal constructor for term x64_popcnt.
4944 pub fn constructor_x64_popcnt<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Option<Gpr> {
4945     let pattern0_0 = arg0;
4946     let pattern1_0 = arg1;
4947     // Rule at src/isa/x64/inst.isle line 2713.
4948     let expr0_0 = C::temp_writable_gpr(ctx);
4949     let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
4950     let expr2_0 = UnaryRmROpcode::Popcnt;
4951     let expr3_0 = C::gpr_to_gpr_mem(ctx, pattern1_0);
4952     let expr4_0 = MInst::UnaryRmR {
4953         size: expr1_0,
4954         op: expr2_0,
4955         src: expr3_0,
4956         dst: expr0_0,
4957     };
4958     let expr5_0 = C::emit(ctx, &expr4_0);
4959     let expr6_0 = C::writable_gpr_to_gpr(ctx, expr0_0);
4960     return Some(expr6_0);
4961 }
4962 
4963 // Generated as internal constructor for term xmm_min_max_seq.
4964 pub fn constructor_xmm_min_max_seq<C: Context>(
4965     ctx: &mut C,
4966     arg0: Type,
4967     arg1: bool,
4968     arg2: Xmm,
4969     arg3: Xmm,
4970 ) -> Option<Xmm> {
4971     let pattern0_0 = arg0;
4972     let pattern1_0 = arg1;
4973     let pattern2_0 = arg2;
4974     let pattern3_0 = arg3;
4975     // Rule at src/isa/x64/inst.isle line 2721.
4976     let expr0_0 = C::temp_writable_xmm(ctx);
4977     let expr1_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
4978     let expr2_0 = MInst::XmmMinMaxSeq {
4979         size: expr1_0,
4980         is_min: pattern1_0,
4981         lhs: pattern2_0,
4982         rhs: pattern3_0,
4983         dst: expr0_0,
4984     };
4985     let expr3_0 = C::emit(ctx, &expr2_0);
4986     let expr4_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
4987     return Some(expr4_0);
4988 }
4989 
4990 // Generated as internal constructor for term x64_minss.
4991 pub fn constructor_x64_minss<C: Context>(ctx: &mut C, arg0: Xmm, arg1: Xmm) -> Option<Xmm> {
4992     let pattern0_0 = arg0;
4993     let pattern1_0 = arg1;
4994     // Rule at src/isa/x64/inst.isle line 2729.
4995     let expr0_0 = C::temp_writable_xmm(ctx);
4996     let expr1_0 = SseOpcode::Minss;
4997     let expr2_0 = C::xmm_to_xmm_mem(ctx, pattern1_0);
4998     let expr3_0 = MInst::XmmRmR {
4999         op: expr1_0,
5000         src1: pattern0_0,
5001         src2: expr2_0,
5002         dst: expr0_0,
5003     };
5004     let expr4_0 = C::emit(ctx, &expr3_0);
5005     let expr5_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
5006     return Some(expr5_0);
5007 }
5008 
5009 // Generated as internal constructor for term x64_minsd.
5010 pub fn constructor_x64_minsd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: Xmm) -> Option<Xmm> {
5011     let pattern0_0 = arg0;
5012     let pattern1_0 = arg1;
5013     // Rule at src/isa/x64/inst.isle line 2736.
5014     let expr0_0 = C::temp_writable_xmm(ctx);
5015     let expr1_0 = SseOpcode::Minsd;
5016     let expr2_0 = C::xmm_to_xmm_mem(ctx, pattern1_0);
5017     let expr3_0 = MInst::XmmRmR {
5018         op: expr1_0,
5019         src1: pattern0_0,
5020         src2: expr2_0,
5021         dst: expr0_0,
5022     };
5023     let expr4_0 = C::emit(ctx, &expr3_0);
5024     let expr5_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
5025     return Some(expr5_0);
5026 }
5027 
5028 // Generated as internal constructor for term x64_minps.
5029 pub fn constructor_x64_minps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: Xmm) -> Option<Xmm> {
5030     let pattern0_0 = arg0;
5031     let pattern1_0 = arg1;
5032     // Rule at src/isa/x64/inst.isle line 2744.
5033     let expr0_0 = C::temp_writable_xmm(ctx);
5034     let expr1_0 = SseOpcode::Minps;
5035     let expr2_0 = C::xmm_to_xmm_mem(ctx, pattern1_0);
5036     let expr3_0 = MInst::XmmRmR {
5037         op: expr1_0,
5038         src1: pattern0_0,
5039         src2: expr2_0,
5040         dst: expr0_0,
5041     };
5042     let expr4_0 = C::emit(ctx, &expr3_0);
5043     let expr5_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
5044     return Some(expr5_0);
5045 }
5046 
5047 // Generated as internal constructor for term x64_minpd.
5048 pub fn constructor_x64_minpd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: Xmm) -> Option<Xmm> {
5049     let pattern0_0 = arg0;
5050     let pattern1_0 = arg1;
5051     // Rule at src/isa/x64/inst.isle line 2751.
5052     let expr0_0 = C::temp_writable_xmm(ctx);
5053     let expr1_0 = SseOpcode::Minpd;
5054     let expr2_0 = C::xmm_to_xmm_mem(ctx, pattern1_0);
5055     let expr3_0 = MInst::XmmRmR {
5056         op: expr1_0,
5057         src1: pattern0_0,
5058         src2: expr2_0,
5059         dst: expr0_0,
5060     };
5061     let expr4_0 = C::emit(ctx, &expr3_0);
5062     let expr5_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
5063     return Some(expr5_0);
5064 }
5065 
5066 // Generated as internal constructor for term x64_maxss.
5067 pub fn constructor_x64_maxss<C: Context>(ctx: &mut C, arg0: Xmm, arg1: Xmm) -> Option<Xmm> {
5068     let pattern0_0 = arg0;
5069     let pattern1_0 = arg1;
5070     // Rule at src/isa/x64/inst.isle line 2758.
5071     let expr0_0 = C::temp_writable_xmm(ctx);
5072     let expr1_0 = SseOpcode::Maxss;
5073     let expr2_0 = C::xmm_to_xmm_mem(ctx, pattern1_0);
5074     let expr3_0 = MInst::XmmRmR {
5075         op: expr1_0,
5076         src1: pattern0_0,
5077         src2: expr2_0,
5078         dst: expr0_0,
5079     };
5080     let expr4_0 = C::emit(ctx, &expr3_0);
5081     let expr5_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
5082     return Some(expr5_0);
5083 }
5084 
5085 // Generated as internal constructor for term x64_maxsd.
5086 pub fn constructor_x64_maxsd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: Xmm) -> Option<Xmm> {
5087     let pattern0_0 = arg0;
5088     let pattern1_0 = arg1;
5089     // Rule at src/isa/x64/inst.isle line 2765.
5090     let expr0_0 = C::temp_writable_xmm(ctx);
5091     let expr1_0 = SseOpcode::Maxsd;
5092     let expr2_0 = C::xmm_to_xmm_mem(ctx, pattern1_0);
5093     let expr3_0 = MInst::XmmRmR {
5094         op: expr1_0,
5095         src1: pattern0_0,
5096         src2: expr2_0,
5097         dst: expr0_0,
5098     };
5099     let expr4_0 = C::emit(ctx, &expr3_0);
5100     let expr5_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
5101     return Some(expr5_0);
5102 }
5103 
5104 // Generated as internal constructor for term x64_maxps.
5105 pub fn constructor_x64_maxps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: Xmm) -> Option<Xmm> {
5106     let pattern0_0 = arg0;
5107     let pattern1_0 = arg1;
5108     // Rule at src/isa/x64/inst.isle line 2772.
5109     let expr0_0 = C::temp_writable_xmm(ctx);
5110     let expr1_0 = SseOpcode::Maxps;
5111     let expr2_0 = C::xmm_to_xmm_mem(ctx, pattern1_0);
5112     let expr3_0 = MInst::XmmRmR {
5113         op: expr1_0,
5114         src1: pattern0_0,
5115         src2: expr2_0,
5116         dst: expr0_0,
5117     };
5118     let expr4_0 = C::emit(ctx, &expr3_0);
5119     let expr5_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
5120     return Some(expr5_0);
5121 }
5122 
5123 // Generated as internal constructor for term x64_maxpd.
5124 pub fn constructor_x64_maxpd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: Xmm) -> Option<Xmm> {
5125     let pattern0_0 = arg0;
5126     let pattern1_0 = arg1;
5127     // Rule at src/isa/x64/inst.isle line 2779.
5128     let expr0_0 = C::temp_writable_xmm(ctx);
5129     let expr1_0 = SseOpcode::Maxpd;
5130     let expr2_0 = C::xmm_to_xmm_mem(ctx, pattern1_0);
5131     let expr3_0 = MInst::XmmRmR {
5132         op: expr1_0,
5133         src1: pattern0_0,
5134         src2: expr2_0,
5135         dst: expr0_0,
5136     };
5137     let expr4_0 = C::emit(ctx, &expr3_0);
5138     let expr5_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
5139     return Some(expr5_0);
5140 }
5141 
5142 // Generated as internal constructor for term x64_sqrtss.
5143 pub fn constructor_x64_sqrtss<C: Context>(ctx: &mut C, arg0: Xmm) -> Option<Xmm> {
5144     let pattern0_0 = arg0;
5145     // Rule at src/isa/x64/inst.isle line 2787.
5146     let expr0_0 = C::temp_writable_xmm(ctx);
5147     let expr1_0 = SseOpcode::Sqrtss;
5148     let expr2_0 = C::xmm_to_xmm_mem(ctx, pattern0_0);
5149     let expr3_0 = MInst::XmmUnaryRmR {
5150         op: expr1_0,
5151         src: expr2_0,
5152         dst: expr0_0,
5153     };
5154     let expr4_0 = C::emit(ctx, &expr3_0);
5155     let expr5_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
5156     return Some(expr5_0);
5157 }
5158 
5159 // Generated as internal constructor for term x64_sqrtsd.
5160 pub fn constructor_x64_sqrtsd<C: Context>(ctx: &mut C, arg0: Xmm) -> Option<Xmm> {
5161     let pattern0_0 = arg0;
5162     // Rule at src/isa/x64/inst.isle line 2794.
5163     let expr0_0 = C::temp_writable_xmm(ctx);
5164     let expr1_0 = SseOpcode::Sqrtsd;
5165     let expr2_0 = C::xmm_to_xmm_mem(ctx, pattern0_0);
5166     let expr3_0 = MInst::XmmUnaryRmR {
5167         op: expr1_0,
5168         src: expr2_0,
5169         dst: expr0_0,
5170     };
5171     let expr4_0 = C::emit(ctx, &expr3_0);
5172     let expr5_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
5173     return Some(expr5_0);
5174 }
5175 
5176 // Generated as internal constructor for term x64_sqrtps.
5177 pub fn constructor_x64_sqrtps<C: Context>(ctx: &mut C, arg0: Xmm) -> Option<Xmm> {
5178     let pattern0_0 = arg0;
5179     // Rule at src/isa/x64/inst.isle line 2801.
5180     let expr0_0 = C::temp_writable_xmm(ctx);
5181     let expr1_0 = SseOpcode::Sqrtps;
5182     let expr2_0 = C::xmm_to_xmm_mem(ctx, pattern0_0);
5183     let expr3_0 = MInst::XmmUnaryRmR {
5184         op: expr1_0,
5185         src: expr2_0,
5186         dst: expr0_0,
5187     };
5188     let expr4_0 = C::emit(ctx, &expr3_0);
5189     let expr5_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
5190     return Some(expr5_0);
5191 }
5192 
5193 // Generated as internal constructor for term x64_sqrtpd.
5194 pub fn constructor_x64_sqrtpd<C: Context>(ctx: &mut C, arg0: Xmm) -> Option<Xmm> {
5195     let pattern0_0 = arg0;
5196     // Rule at src/isa/x64/inst.isle line 2808.
5197     let expr0_0 = C::temp_writable_xmm(ctx);
5198     let expr1_0 = SseOpcode::Sqrtpd;
5199     let expr2_0 = C::xmm_to_xmm_mem(ctx, pattern0_0);
5200     let expr3_0 = MInst::XmmUnaryRmR {
5201         op: expr1_0,
5202         src: expr2_0,
5203         dst: expr0_0,
5204     };
5205     let expr4_0 = C::emit(ctx, &expr3_0);
5206     let expr5_0 = C::writable_xmm_to_xmm(ctx, expr0_0);
5207     return Some(expr5_0);
5208 }
5209 
5210 // Generated as internal constructor for term x64_pcmpeq.
5211 pub fn constructor_x64_pcmpeq<C: Context>(
5212     ctx: &mut C,
5213     arg0: Type,
5214     arg1: Xmm,
5215     arg2: &XmmMem,
5216 ) -> Option<Xmm> {
5217     let pattern0_0 = arg0;
5218     if pattern0_0 == I8X16 {
5219         let pattern2_0 = arg1;
5220         let pattern3_0 = arg2;
5221         // Rule at src/isa/x64/inst.isle line 2815.
5222         let expr0_0 = constructor_x64_pcmpeqb(ctx, pattern2_0, pattern3_0)?;
5223         return Some(expr0_0);
5224     }
5225     if pattern0_0 == I16X8 {
5226         let pattern2_0 = arg1;
5227         let pattern3_0 = arg2;
5228         // Rule at src/isa/x64/inst.isle line 2816.
5229         let expr0_0 = constructor_x64_pcmpeqw(ctx, pattern2_0, pattern3_0)?;
5230         return Some(expr0_0);
5231     }
5232     if pattern0_0 == I32X4 {
5233         let pattern2_0 = arg1;
5234         let pattern3_0 = arg2;
5235         // Rule at src/isa/x64/inst.isle line 2817.
5236         let expr0_0 = constructor_x64_pcmpeqd(ctx, pattern2_0, pattern3_0)?;
5237         return Some(expr0_0);
5238     }
5239     if pattern0_0 == I64X2 {
5240         let pattern2_0 = arg1;
5241         let pattern3_0 = arg2;
5242         // Rule at src/isa/x64/inst.isle line 2818.
5243         let expr0_0 = constructor_x64_pcmpeqq(ctx, pattern2_0, pattern3_0)?;
5244         return Some(expr0_0);
5245     }
5246     return None;
5247 }
5248 
5249 // Generated as internal constructor for term x64_pcmpeqb.
5250 pub fn constructor_x64_pcmpeqb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
5251     let pattern0_0 = arg0;
5252     let pattern1_0 = arg1;
5253     // Rule at src/isa/x64/inst.isle line 2821.
5254     let expr0_0: Type = I8X16;
5255     let expr1_0 = SseOpcode::Pcmpeqb;
5256     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
5257     return Some(expr2_0);
5258 }
5259 
5260 // Generated as internal constructor for term x64_pcmpeqw.
5261 pub fn constructor_x64_pcmpeqw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
5262     let pattern0_0 = arg0;
5263     let pattern1_0 = arg1;
5264     // Rule at src/isa/x64/inst.isle line 2823.
5265     let expr0_0: Type = I16X8;
5266     let expr1_0 = SseOpcode::Pcmpeqw;
5267     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
5268     return Some(expr2_0);
5269 }
5270 
5271 // Generated as internal constructor for term x64_pcmpeqd.
5272 pub fn constructor_x64_pcmpeqd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
5273     let pattern0_0 = arg0;
5274     let pattern1_0 = arg1;
5275     // Rule at src/isa/x64/inst.isle line 2825.
5276     let expr0_0: Type = I32X4;
5277     let expr1_0 = SseOpcode::Pcmpeqd;
5278     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
5279     return Some(expr2_0);
5280 }
5281 
5282 // Generated as internal constructor for term x64_pcmpeqq.
5283 pub fn constructor_x64_pcmpeqq<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
5284     let pattern0_0 = arg0;
5285     let pattern1_0 = arg1;
5286     // Rule at src/isa/x64/inst.isle line 2827.
5287     let expr0_0: Type = I64X2;
5288     let expr1_0 = SseOpcode::Pcmpeqq;
5289     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
5290     return Some(expr2_0);
5291 }
5292 
5293 // Generated as internal constructor for term x64_pcmpgt.
5294 pub fn constructor_x64_pcmpgt<C: Context>(
5295     ctx: &mut C,
5296     arg0: Type,
5297     arg1: Xmm,
5298     arg2: &XmmMem,
5299 ) -> Option<Xmm> {
5300     let pattern0_0 = arg0;
5301     if pattern0_0 == I8X16 {
5302         let pattern2_0 = arg1;
5303         let pattern3_0 = arg2;
5304         // Rule at src/isa/x64/inst.isle line 2831.
5305         let expr0_0 = constructor_x64_pcmpgtb(ctx, pattern2_0, pattern3_0)?;
5306         return Some(expr0_0);
5307     }
5308     if pattern0_0 == I16X8 {
5309         let pattern2_0 = arg1;
5310         let pattern3_0 = arg2;
5311         // Rule at src/isa/x64/inst.isle line 2832.
5312         let expr0_0 = constructor_x64_pcmpgtw(ctx, pattern2_0, pattern3_0)?;
5313         return Some(expr0_0);
5314     }
5315     if pattern0_0 == I32X4 {
5316         let pattern2_0 = arg1;
5317         let pattern3_0 = arg2;
5318         // Rule at src/isa/x64/inst.isle line 2833.
5319         let expr0_0 = constructor_x64_pcmpgtd(ctx, pattern2_0, pattern3_0)?;
5320         return Some(expr0_0);
5321     }
5322     if pattern0_0 == I64X2 {
5323         let pattern2_0 = arg1;
5324         let pattern3_0 = arg2;
5325         // Rule at src/isa/x64/inst.isle line 2834.
5326         let expr0_0 = constructor_x64_pcmpgtq(ctx, pattern2_0, pattern3_0)?;
5327         return Some(expr0_0);
5328     }
5329     return None;
5330 }
5331 
5332 // Generated as internal constructor for term x64_pcmpgtb.
5333 pub fn constructor_x64_pcmpgtb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
5334     let pattern0_0 = arg0;
5335     let pattern1_0 = arg1;
5336     // Rule at src/isa/x64/inst.isle line 2837.
5337     let expr0_0: Type = I8X16;
5338     let expr1_0 = SseOpcode::Pcmpgtb;
5339     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
5340     return Some(expr2_0);
5341 }
5342 
5343 // Generated as internal constructor for term x64_pcmpgtw.
5344 pub fn constructor_x64_pcmpgtw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
5345     let pattern0_0 = arg0;
5346     let pattern1_0 = arg1;
5347     // Rule at src/isa/x64/inst.isle line 2839.
5348     let expr0_0: Type = I16X8;
5349     let expr1_0 = SseOpcode::Pcmpgtw;
5350     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
5351     return Some(expr2_0);
5352 }
5353 
5354 // Generated as internal constructor for term x64_pcmpgtd.
5355 pub fn constructor_x64_pcmpgtd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
5356     let pattern0_0 = arg0;
5357     let pattern1_0 = arg1;
5358     // Rule at src/isa/x64/inst.isle line 2841.
5359     let expr0_0: Type = I32X4;
5360     let expr1_0 = SseOpcode::Pcmpgtd;
5361     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
5362     return Some(expr2_0);
5363 }
5364 
5365 // Generated as internal constructor for term x64_pcmpgtq.
5366 pub fn constructor_x64_pcmpgtq<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Option<Xmm> {
5367     let pattern0_0 = arg0;
5368     let pattern1_0 = arg1;
5369     // Rule at src/isa/x64/inst.isle line 2843.
5370     let expr0_0: Type = I64X2;
5371     let expr1_0 = SseOpcode::Pcmpgtq;
5372     let expr2_0 = constructor_xmm_rm_r(ctx, expr0_0, &expr1_0, pattern0_0, pattern1_0)?;
5373     return Some(expr2_0);
5374 }
5375 
5376 // Generated as internal constructor for term alu_rm.
5377 pub fn constructor_alu_rm<C: Context>(
5378     ctx: &mut C,
5379     arg0: Type,
5380     arg1: &AluRmiROpcode,
5381     arg2: &Amode,
5382     arg3: Gpr,
5383 ) -> Option<SideEffectNoResult> {
5384     let pattern0_0 = arg0;
5385     let pattern1_0 = arg1;
5386     let pattern2_0 = arg2;
5387     let pattern3_0 = arg3;
5388     // Rule at src/isa/x64/inst.isle line 2847.
5389     let expr0_0 = C::operand_size_of_type_32_64(ctx, pattern0_0);
5390     let expr1_0 = C::amode_to_synthetic_amode(ctx, pattern2_0);
5391     let expr2_0 = MInst::AluRM {
5392         size: expr0_0,
5393         op: pattern1_0.clone(),
5394         src1_dst: expr1_0,
5395         src2: pattern3_0,
5396     };
5397     let expr3_0 = SideEffectNoResult::Inst { inst: expr2_0 };
5398     return Some(expr3_0);
5399 }
5400 
5401 // Generated as internal constructor for term x64_add_mem.
5402 pub fn constructor_x64_add_mem<C: Context>(
5403     ctx: &mut C,
5404     arg0: Type,
5405     arg1: &Amode,
5406     arg2: Gpr,
5407 ) -> Option<SideEffectNoResult> {
5408     let pattern0_0 = arg0;
5409     let pattern1_0 = arg1;
5410     let pattern2_0 = arg2;
5411     // Rule at src/isa/x64/inst.isle line 2852.
5412     let expr0_0 = AluRmiROpcode::Add;
5413     let expr1_0 = constructor_alu_rm(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?;
5414     return Some(expr1_0);
5415 }
5416 
5417 // Generated as internal constructor for term x64_sub_mem.
5418 pub fn constructor_x64_sub_mem<C: Context>(
5419     ctx: &mut C,
5420     arg0: Type,
5421     arg1: &Amode,
5422     arg2: Gpr,
5423 ) -> Option<SideEffectNoResult> {
5424     let pattern0_0 = arg0;
5425     let pattern1_0 = arg1;
5426     let pattern2_0 = arg2;
5427     // Rule at src/isa/x64/inst.isle line 2856.
5428     let expr0_0 = AluRmiROpcode::Sub;
5429     let expr1_0 = constructor_alu_rm(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?;
5430     return Some(expr1_0);
5431 }
5432 
5433 // Generated as internal constructor for term x64_and_mem.
5434 pub fn constructor_x64_and_mem<C: Context>(
5435     ctx: &mut C,
5436     arg0: Type,
5437     arg1: &Amode,
5438     arg2: Gpr,
5439 ) -> Option<SideEffectNoResult> {
5440     let pattern0_0 = arg0;
5441     let pattern1_0 = arg1;
5442     let pattern2_0 = arg2;
5443     // Rule at src/isa/x64/inst.isle line 2860.
5444     let expr0_0 = AluRmiROpcode::And;
5445     let expr1_0 = constructor_alu_rm(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?;
5446     return Some(expr1_0);
5447 }
5448 
5449 // Generated as internal constructor for term x64_or_mem.
5450 pub fn constructor_x64_or_mem<C: Context>(
5451     ctx: &mut C,
5452     arg0: Type,
5453     arg1: &Amode,
5454     arg2: Gpr,
5455 ) -> Option<SideEffectNoResult> {
5456     let pattern0_0 = arg0;
5457     let pattern1_0 = arg1;
5458     let pattern2_0 = arg2;
5459     // Rule at src/isa/x64/inst.isle line 2864.
5460     let expr0_0 = AluRmiROpcode::Or;
5461     let expr1_0 = constructor_alu_rm(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?;
5462     return Some(expr1_0);
5463 }
5464 
5465 // Generated as internal constructor for term x64_xor_mem.
5466 pub fn constructor_x64_xor_mem<C: Context>(
5467     ctx: &mut C,
5468     arg0: Type,
5469     arg1: &Amode,
5470     arg2: Gpr,
5471 ) -> Option<SideEffectNoResult> {
5472     let pattern0_0 = arg0;
5473     let pattern1_0 = arg1;
5474     let pattern2_0 = arg2;
5475     // Rule at src/isa/x64/inst.isle line 2868.
5476     let expr0_0 = AluRmiROpcode::Xor;
5477     let expr1_0 = constructor_alu_rm(ctx, pattern0_0, &expr0_0, pattern1_0, pattern2_0)?;
5478     return Some(expr1_0);
5479 }
5480 
5481 // Generated as internal constructor for term reg_to_xmm_mem.
5482 pub fn constructor_reg_to_xmm_mem<C: Context>(ctx: &mut C, arg0: Reg) -> Option<XmmMem> {
5483     let pattern0_0 = arg0;
5484     // Rule at src/isa/x64/inst.isle line 2925.
5485     let expr0_0 = C::xmm_new(ctx, pattern0_0);
5486     let expr1_0 = C::xmm_to_xmm_mem(ctx, expr0_0);
5487     return Some(expr1_0);
5488 }
5489 
5490 // Generated as internal constructor for term xmm_to_reg_mem.
5491 pub fn constructor_xmm_to_reg_mem<C: Context>(ctx: &mut C, arg0: Reg) -> Option<XmmMem> {
5492     let pattern0_0 = arg0;
5493     // Rule at src/isa/x64/inst.isle line 2928.
5494     let expr0_0 = C::xmm_new(ctx, pattern0_0);
5495     let expr1_0 = C::xmm_to_reg(ctx, expr0_0);
5496     let expr2_0 = RegMem::Reg { reg: expr1_0 };
5497     let expr3_0 = C::reg_mem_to_xmm_mem(ctx, &expr2_0);
5498     return Some(expr3_0);
5499 }
5500 
5501 // Generated as internal constructor for term writable_gpr_to_r_reg.
5502 pub fn constructor_writable_gpr_to_r_reg<C: Context>(
5503     ctx: &mut C,
5504     arg0: WritableGpr,
5505 ) -> Option<Reg> {
5506     let pattern0_0 = arg0;
5507     // Rule at src/isa/x64/inst.isle line 2932.
5508     let expr0_0 = C::writable_gpr_to_reg(ctx, pattern0_0);
5509     let expr1_0 = C::writable_reg_to_reg(ctx, expr0_0);
5510     return Some(expr1_0);
5511 }
5512 
5513 // Generated as internal constructor for term writable_gpr_to_gpr_mem.
5514 pub fn constructor_writable_gpr_to_gpr_mem<C: Context>(
5515     ctx: &mut C,
5516     arg0: WritableGpr,
5517 ) -> Option<GprMem> {
5518     let pattern0_0 = arg0;
5519     // Rule at src/isa/x64/inst.isle line 2935.
5520     let expr0_0 = C::writable_gpr_to_gpr(ctx, pattern0_0);
5521     let expr1_0 = C::gpr_to_gpr_mem(ctx, expr0_0);
5522     return Some(expr1_0);
5523 }
5524 
5525 // Generated as internal constructor for term writable_gpr_to_value_regs.
5526 pub fn constructor_writable_gpr_to_value_regs<C: Context>(
5527     ctx: &mut C,
5528     arg0: WritableGpr,
5529 ) -> Option<ValueRegs> {
5530     let pattern0_0 = arg0;
5531     // Rule at src/isa/x64/inst.isle line 2938.
5532     let expr0_0 = constructor_writable_gpr_to_r_reg(ctx, pattern0_0)?;
5533     let expr1_0 = C::value_reg(ctx, expr0_0);
5534     return Some(expr1_0);
5535 }
5536 
5537 // Generated as internal constructor for term writable_xmm_to_r_reg.
5538 pub fn constructor_writable_xmm_to_r_reg<C: Context>(
5539     ctx: &mut C,
5540     arg0: WritableXmm,
5541 ) -> Option<Reg> {
5542     let pattern0_0 = arg0;
5543     // Rule at src/isa/x64/inst.isle line 2941.
5544     let expr0_0 = C::writable_xmm_to_reg(ctx, pattern0_0);
5545     let expr1_0 = C::writable_reg_to_reg(ctx, expr0_0);
5546     return Some(expr1_0);
5547 }
5548 
5549 // Generated as internal constructor for term writable_xmm_to_xmm_mem.
5550 pub fn constructor_writable_xmm_to_xmm_mem<C: Context>(
5551     ctx: &mut C,
5552     arg0: WritableXmm,
5553 ) -> Option<XmmMem> {
5554     let pattern0_0 = arg0;
5555     // Rule at src/isa/x64/inst.isle line 2944.
5556     let expr0_0 = C::writable_xmm_to_xmm(ctx, pattern0_0);
5557     let expr1_0 = C::xmm_to_xmm_mem(ctx, expr0_0);
5558     return Some(expr1_0);
5559 }
5560 
5561 // Generated as internal constructor for term writable_xmm_to_value_regs.
5562 pub fn constructor_writable_xmm_to_value_regs<C: Context>(
5563     ctx: &mut C,
5564     arg0: WritableXmm,
5565 ) -> Option<ValueRegs> {
5566     let pattern0_0 = arg0;
5567     // Rule at src/isa/x64/inst.isle line 2947.
5568     let expr0_0 = constructor_writable_xmm_to_r_reg(ctx, pattern0_0)?;
5569     let expr1_0 = C::value_reg(ctx, expr0_0);
5570     return Some(expr1_0);
5571 }
5572 
5573 // Generated as internal constructor for term synthetic_amode_to_gpr_mem.
5574 pub fn constructor_synthetic_amode_to_gpr_mem<C: Context>(
5575     ctx: &mut C,
5576     arg0: &SyntheticAmode,
5577 ) -> Option<GprMem> {
5578     let pattern0_0 = arg0;
5579     // Rule at src/isa/x64/inst.isle line 2954.
5580     let expr0_0 = C::synthetic_amode_to_reg_mem(ctx, pattern0_0);
5581     let expr1_0 = C::reg_mem_to_gpr_mem(ctx, &expr0_0);
5582     return Some(expr1_0);
5583 }
5584 
5585 // Generated as internal constructor for term amode_to_gpr_mem.
5586 pub fn constructor_amode_to_gpr_mem<C: Context>(ctx: &mut C, arg0: &Amode) -> Option<GprMem> {
5587     let pattern0_0 = arg0;
5588     // Rule at src/isa/x64/inst.isle line 2952.
5589     let expr0_0 = C::amode_to_synthetic_amode(ctx, pattern0_0);
5590     let expr1_0 = constructor_synthetic_amode_to_gpr_mem(ctx, &expr0_0)?;
5591     return Some(expr1_0);
5592 }
5593 
5594 // Generated as internal constructor for term amode_to_xmm_mem.
5595 pub fn constructor_amode_to_xmm_mem<C: Context>(ctx: &mut C, arg0: &Amode) -> Option<XmmMem> {
5596     let pattern0_0 = arg0;
5597     // Rule at src/isa/x64/inst.isle line 2957.
5598     let expr0_0 = C::amode_to_synthetic_amode(ctx, pattern0_0);
5599     let expr1_0 = constructor_synthetic_amode_to_xmm_mem(ctx, &expr0_0)?;
5600     return Some(expr1_0);
5601 }
5602 
5603 // Generated as internal constructor for term synthetic_amode_to_xmm_mem.
5604 pub fn constructor_synthetic_amode_to_xmm_mem<C: Context>(
5605     ctx: &mut C,
5606     arg0: &SyntheticAmode,
5607 ) -> Option<XmmMem> {
5608     let pattern0_0 = arg0;
5609     // Rule at src/isa/x64/inst.isle line 2960.
5610     let expr0_0 = C::synthetic_amode_to_reg_mem(ctx, pattern0_0);
5611     let expr1_0 = C::reg_mem_to_xmm_mem(ctx, &expr0_0);
5612     return Some(expr1_0);
5613 }
5614 
5615 // Generated as internal constructor for term lower.
5616 pub fn constructor_lower<C: Context>(ctx: &mut C, arg0: Inst) -> Option<InstOutput> {
5617     let pattern0_0 = arg0;
5618     if let Some(pattern1_0) = C::first_result(ctx, pattern0_0) {
5619         let pattern2_0 = C::value_type(ctx, pattern1_0);
5620         if pattern2_0 == I128 {
5621             if let Some(()) = C::use_popcnt(ctx, pattern2_0) {
5622                 let pattern5_0 = C::inst_data(ctx, pattern0_0);
5623                 if let &InstructionData::Unary {
5624                     opcode: ref pattern6_0,
5625                     arg: pattern6_1,
5626                 } = &pattern5_0
5627                 {
5628                     if let &Opcode::Popcnt = pattern6_0 {
5629                         // Rule at src/isa/x64/lower.isle line 1876.
5630                         let expr0_0: Type = I64;
5631                         let expr1_0 = C::put_in_regs(ctx, pattern6_1);
5632                         let expr2_0: usize = 0;
5633                         let expr3_0 = constructor_value_regs_get_gpr(ctx, expr1_0, expr2_0)?;
5634                         let expr4_0 = constructor_x64_popcnt(ctx, expr0_0, expr3_0)?;
5635                         let expr5_0: Type = I64;
5636                         let expr6_0 = C::put_in_regs(ctx, pattern6_1);
5637                         let expr7_0: usize = 1;
5638                         let expr8_0 = constructor_value_regs_get_gpr(ctx, expr6_0, expr7_0)?;
5639                         let expr9_0 = constructor_x64_popcnt(ctx, expr5_0, expr8_0)?;
5640                         let expr10_0: Type = I64;
5641                         let expr11_0 = C::gpr_to_gpr_mem_imm(ctx, expr9_0);
5642                         let expr12_0 = constructor_x64_add(ctx, expr10_0, expr4_0, &expr11_0)?;
5643                         let expr13_0 = C::gpr_to_reg(ctx, expr12_0);
5644                         let expr14_0: Type = I64;
5645                         let expr15_0: u64 = 0;
5646                         let expr16_0 = constructor_imm(ctx, expr14_0, expr15_0)?;
5647                         let expr17_0 = C::value_regs(ctx, expr13_0, expr16_0);
5648                         let expr18_0 = C::output(ctx, expr17_0);
5649                         return Some(expr18_0);
5650                     }
5651                 }
5652             }
5653         }
5654         if pattern2_0 == I8X16 {
5655             if let Some(()) = C::avx512vl_enabled(ctx, pattern2_0) {
5656                 if let Some(()) = C::avx512bitalg_enabled(ctx, pattern2_0) {
5657                     let pattern6_0 = C::inst_data(ctx, pattern0_0);
5658                     if let &InstructionData::Unary {
5659                         opcode: ref pattern7_0,
5660                         arg: pattern7_1,
5661                     } = &pattern6_0
5662                     {
5663                         if let &Opcode::Popcnt = pattern7_0 {
5664                             // Rule at src/isa/x64/lower.isle line 1968.
5665                             let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
5666                             let expr1_0 = constructor_x64_vpopcntb(ctx, &expr0_0)?;
5667                             let expr2_0 = constructor_output_xmm(ctx, expr1_0)?;
5668                             return Some(expr2_0);
5669                         }
5670                     }
5671                 }
5672             }
5673         }
5674         if let Some(pattern3_0) = C::ty_32_or_64(ctx, pattern2_0) {
5675             if let Some(()) = C::use_lzcnt(ctx, pattern2_0) {
5676                 let pattern5_0 = C::inst_data(ctx, pattern0_0);
5677                 if let &InstructionData::Unary {
5678                     opcode: ref pattern6_0,
5679                     arg: pattern6_1,
5680                 } = &pattern5_0
5681                 {
5682                     if let &Opcode::Clz = pattern6_0 {
5683                         // Rule at src/isa/x64/lower.isle line 1784.
5684                         let expr0_0 = constructor_put_in_gpr(ctx, pattern6_1)?;
5685                         let expr1_0 = constructor_x64_lzcnt(ctx, pattern3_0, expr0_0)?;
5686                         let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
5687                         return Some(expr2_0);
5688                     }
5689                 }
5690             }
5691             if let Some(()) = C::use_bmi1(ctx, pattern2_0) {
5692                 let pattern5_0 = C::inst_data(ctx, pattern0_0);
5693                 if let &InstructionData::Unary {
5694                     opcode: ref pattern6_0,
5695                     arg: pattern6_1,
5696                 } = &pattern5_0
5697                 {
5698                     if let &Opcode::Ctz = pattern6_0 {
5699                         // Rule at src/isa/x64/lower.isle line 1826.
5700                         let expr0_0 = constructor_put_in_gpr(ctx, pattern6_1)?;
5701                         let expr1_0 = constructor_x64_tzcnt(ctx, pattern3_0, expr0_0)?;
5702                         let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
5703                         return Some(expr2_0);
5704                     }
5705                 }
5706             }
5707             if let Some(()) = C::use_popcnt(ctx, pattern2_0) {
5708                 let pattern5_0 = C::inst_data(ctx, pattern0_0);
5709                 if let &InstructionData::Unary {
5710                     opcode: ref pattern6_0,
5711                     arg: pattern6_1,
5712                 } = &pattern5_0
5713                 {
5714                     if let &Opcode::Popcnt = pattern6_0 {
5715                         // Rule at src/isa/x64/lower.isle line 1862.
5716                         let expr0_0 = constructor_put_in_gpr(ctx, pattern6_1)?;
5717                         let expr1_0 = constructor_x64_popcnt(ctx, pattern3_0, expr0_0)?;
5718                         let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
5719                         return Some(expr2_0);
5720                     }
5721                 }
5722             }
5723         }
5724         if let Some(pattern3_0) = C::ty_8_or_16(ctx, pattern2_0) {
5725             if let Some(()) = C::use_popcnt(ctx, pattern2_0) {
5726                 let pattern5_0 = C::inst_data(ctx, pattern0_0);
5727                 if let &InstructionData::Unary {
5728                     opcode: ref pattern6_0,
5729                     arg: pattern6_1,
5730                 } = &pattern5_0
5731                 {
5732                     if let &Opcode::Popcnt = pattern6_0 {
5733                         // Rule at src/isa/x64/lower.isle line 1869.
5734                         let expr0_0: Type = I32;
5735                         let expr1_0: Type = I32;
5736                         let expr2_0 = ExtendKind::Zero;
5737                         let expr3_0 =
5738                             constructor_extend_to_gpr(ctx, pattern6_1, expr1_0, &expr2_0)?;
5739                         let expr4_0 = constructor_x64_popcnt(ctx, expr0_0, expr3_0)?;
5740                         let expr5_0 = constructor_output_gpr(ctx, expr4_0)?;
5741                         return Some(expr5_0);
5742                     }
5743                 }
5744             }
5745         }
5746     }
5747     let pattern0_0 = arg0;
5748     let pattern1_0 = C::inst_data(ctx, pattern0_0);
5749     match &pattern1_0 {
5750         &InstructionData::NullAry {
5751             opcode: ref pattern2_0,
5752         } => {
5753             if let &Opcode::Debugtrap = pattern2_0 {
5754                 // Rule at src/isa/x64/lower.isle line 2254.
5755                 let expr0_0 = constructor_x64_hlt(ctx)?;
5756                 let expr1_0 = constructor_side_effect(ctx, &expr0_0)?;
5757                 return Some(expr1_0);
5758             }
5759         }
5760         &InstructionData::UnaryIeee32 {
5761             opcode: ref pattern2_0,
5762             imm: pattern2_1,
5763         } => {
5764             if let &Opcode::F32const = pattern2_0 {
5765                 let pattern4_0 = C::u64_from_ieee32(ctx, pattern2_1);
5766                 // Rule at src/isa/x64/lower.isle line 46.
5767                 let expr0_0: Type = F32;
5768                 let expr1_0 = constructor_imm(ctx, expr0_0, pattern4_0)?;
5769                 let expr2_0 = constructor_output_reg(ctx, expr1_0)?;
5770                 return Some(expr2_0);
5771             }
5772         }
5773         &InstructionData::UnaryIeee64 {
5774             opcode: ref pattern2_0,
5775             imm: pattern2_1,
5776         } => {
5777             if let &Opcode::F64const = pattern2_0 {
5778                 let pattern4_0 = C::u64_from_ieee64(ctx, pattern2_1);
5779                 // Rule at src/isa/x64/lower.isle line 51.
5780                 let expr0_0: Type = F64;
5781                 let expr1_0 = constructor_imm(ctx, expr0_0, pattern4_0)?;
5782                 let expr2_0 = constructor_output_reg(ctx, expr1_0)?;
5783                 return Some(expr2_0);
5784             }
5785         }
5786         &InstructionData::Trap {
5787             opcode: ref pattern2_0,
5788             code: ref pattern2_1,
5789         } => {
5790             match pattern2_0 {
5791                 &Opcode::Trap => {
5792                     // Rule at src/isa/x64/lower.isle line 1438.
5793                     let expr0_0 = constructor_x64_ud2(ctx, pattern2_1)?;
5794                     let expr1_0 = constructor_side_effect(ctx, &expr0_0)?;
5795                     return Some(expr1_0);
5796                 }
5797                 &Opcode::ResumableTrap => {
5798                     // Rule at src/isa/x64/lower.isle line 1443.
5799                     let expr0_0 = constructor_x64_ud2(ctx, pattern2_1)?;
5800                     let expr1_0 = constructor_side_effect(ctx, &expr0_0)?;
5801                     return Some(expr1_0);
5802                 }
5803                 _ => {}
5804             }
5805         }
5806         &InstructionData::Store {
5807             opcode: ref pattern2_0,
5808             args: ref pattern2_1,
5809             flags: pattern2_2,
5810             offset: pattern2_3,
5811         } => {
5812             match pattern2_0 {
5813                 &Opcode::Store => {
5814                     let (pattern4_0, pattern4_1) = C::unpack_value_array_2(ctx, pattern2_1);
5815                     if let Some(pattern5_0) = C::def_inst(ctx, pattern4_0) {
5816                         if let Some(pattern6_0) = C::first_result(ctx, pattern5_0) {
5817                             let pattern7_0 = C::value_type(ctx, pattern6_0);
5818                             if let Some(pattern8_0) = C::ty_32_or_64(ctx, pattern7_0) {
5819                                 let pattern9_0 = C::inst_data(ctx, pattern5_0);
5820                                 if let &InstructionData::Binary {
5821                                     opcode: ref pattern10_0,
5822                                     args: ref pattern10_1,
5823                                 } = &pattern9_0
5824                                 {
5825                                     match pattern10_0 {
5826                                         &Opcode::Iadd => {
5827                                             let (pattern12_0, pattern12_1) =
5828                                                 C::unpack_value_array_2(ctx, pattern10_1);
5829                                             if let Some(pattern13_0) =
5830                                                 C::sinkable_load(ctx, pattern12_0)
5831                                             {
5832                                                 if let Some(pattern14_0) =
5833                                                     C::def_inst(ctx, pattern12_0)
5834                                                 {
5835                                                     let pattern15_0 =
5836                                                         C::inst_data(ctx, pattern14_0);
5837                                                     if let &InstructionData::Load {
5838                                                         opcode: ref pattern16_0,
5839                                                         arg: pattern16_1,
5840                                                         flags: pattern16_2,
5841                                                         offset: pattern16_3,
5842                                                     } = &pattern15_0
5843                                                     {
5844                                                         if let &Opcode::Load = pattern16_0 {
5845                                                             if pattern4_1 == pattern16_1 {
5846                                                                 if pattern2_2 == pattern16_2 {
5847                                                                     if pattern2_3 == pattern16_3 {
5848                                                                         // Rule at src/isa/x64/lower.isle line 2662.
5849                                                                         let expr0_0 = C::sink_load(
5850                                                                             ctx,
5851                                                                             &pattern13_0,
5852                                                                         );
5853                                                                         let expr1_0 =
5854                                                                             constructor_to_amode(
5855                                                                                 ctx,
5856                                                                                 pattern16_2,
5857                                                                                 pattern16_1,
5858                                                                                 pattern16_3,
5859                                                                             )?;
5860                                                                         let expr2_0 =
5861                                                                             constructor_put_in_gpr(
5862                                                                                 ctx,
5863                                                                                 pattern12_1,
5864                                                                             )?;
5865                                                                         let expr3_0 = constructor_x64_add_mem(ctx, pattern8_0, &expr1_0, expr2_0)?;
5866                                                                         let expr4_0 = constructor_side_effect(ctx, &expr3_0)?;
5867                                                                         return Some(expr4_0);
5868                                                                     }
5869                                                                 }
5870                                                             }
5871                                                         }
5872                                                     }
5873                                                 }
5874                                             }
5875                                             if let Some(pattern13_0) =
5876                                                 C::sinkable_load(ctx, pattern12_1)
5877                                             {
5878                                                 if let Some(pattern14_0) =
5879                                                     C::def_inst(ctx, pattern12_1)
5880                                                 {
5881                                                     let pattern15_0 =
5882                                                         C::inst_data(ctx, pattern14_0);
5883                                                     if let &InstructionData::Load {
5884                                                         opcode: ref pattern16_0,
5885                                                         arg: pattern16_1,
5886                                                         flags: pattern16_2,
5887                                                         offset: pattern16_3,
5888                                                     } = &pattern15_0
5889                                                     {
5890                                                         if let &Opcode::Load = pattern16_0 {
5891                                                             if pattern4_1 == pattern16_1 {
5892                                                                 if pattern2_2 == pattern16_2 {
5893                                                                     if pattern2_3 == pattern16_3 {
5894                                                                         // Rule at src/isa/x64/lower.isle line 2676.
5895                                                                         let expr0_0 = C::sink_load(
5896                                                                             ctx,
5897                                                                             &pattern13_0,
5898                                                                         );
5899                                                                         let expr1_0 =
5900                                                                             constructor_to_amode(
5901                                                                                 ctx,
5902                                                                                 pattern16_2,
5903                                                                                 pattern16_1,
5904                                                                                 pattern16_3,
5905                                                                             )?;
5906                                                                         let expr2_0 =
5907                                                                             constructor_put_in_gpr(
5908                                                                                 ctx,
5909                                                                                 pattern12_0,
5910                                                                             )?;
5911                                                                         let expr3_0 = constructor_x64_add_mem(ctx, pattern8_0, &expr1_0, expr2_0)?;
5912                                                                         let expr4_0 = constructor_side_effect(ctx, &expr3_0)?;
5913                                                                         return Some(expr4_0);
5914                                                                     }
5915                                                                 }
5916                                                             }
5917                                                         }
5918                                                     }
5919                                                 }
5920                                             }
5921                                         }
5922                                         &Opcode::Isub => {
5923                                             let (pattern12_0, pattern12_1) =
5924                                                 C::unpack_value_array_2(ctx, pattern10_1);
5925                                             if let Some(pattern13_0) =
5926                                                 C::sinkable_load(ctx, pattern12_0)
5927                                             {
5928                                                 if let Some(pattern14_0) =
5929                                                     C::def_inst(ctx, pattern12_0)
5930                                                 {
5931                                                     let pattern15_0 =
5932                                                         C::inst_data(ctx, pattern14_0);
5933                                                     if let &InstructionData::Load {
5934                                                         opcode: ref pattern16_0,
5935                                                         arg: pattern16_1,
5936                                                         flags: pattern16_2,
5937                                                         offset: pattern16_3,
5938                                                     } = &pattern15_0
5939                                                     {
5940                                                         if let &Opcode::Load = pattern16_0 {
5941                                                             if pattern4_1 == pattern16_1 {
5942                                                                 if pattern2_2 == pattern16_2 {
5943                                                                     if pattern2_3 == pattern16_3 {
5944                                                                         // Rule at src/isa/x64/lower.isle line 2690.
5945                                                                         let expr0_0 = C::sink_load(
5946                                                                             ctx,
5947                                                                             &pattern13_0,
5948                                                                         );
5949                                                                         let expr1_0 =
5950                                                                             constructor_to_amode(
5951                                                                                 ctx,
5952                                                                                 pattern16_2,
5953                                                                                 pattern16_1,
5954                                                                                 pattern16_3,
5955                                                                             )?;
5956                                                                         let expr2_0 =
5957                                                                             constructor_put_in_gpr(
5958                                                                                 ctx,
5959                                                                                 pattern12_1,
5960                                                                             )?;
5961                                                                         let expr3_0 = constructor_x64_sub_mem(ctx, pattern8_0, &expr1_0, expr2_0)?;
5962                                                                         let expr4_0 = constructor_side_effect(ctx, &expr3_0)?;
5963                                                                         return Some(expr4_0);
5964                                                                     }
5965                                                                 }
5966                                                             }
5967                                                         }
5968                                                     }
5969                                                 }
5970                                             }
5971                                         }
5972                                         &Opcode::Band => {
5973                                             let (pattern12_0, pattern12_1) =
5974                                                 C::unpack_value_array_2(ctx, pattern10_1);
5975                                             if let Some(pattern13_0) =
5976                                                 C::sinkable_load(ctx, pattern12_0)
5977                                             {
5978                                                 if let Some(pattern14_0) =
5979                                                     C::def_inst(ctx, pattern12_0)
5980                                                 {
5981                                                     let pattern15_0 =
5982                                                         C::inst_data(ctx, pattern14_0);
5983                                                     if let &InstructionData::Load {
5984                                                         opcode: ref pattern16_0,
5985                                                         arg: pattern16_1,
5986                                                         flags: pattern16_2,
5987                                                         offset: pattern16_3,
5988                                                     } = &pattern15_0
5989                                                     {
5990                                                         if let &Opcode::Load = pattern16_0 {
5991                                                             if pattern4_1 == pattern16_1 {
5992                                                                 if pattern2_2 == pattern16_2 {
5993                                                                     if pattern2_3 == pattern16_3 {
5994                                                                         // Rule at src/isa/x64/lower.isle line 2704.
5995                                                                         let expr0_0 = C::sink_load(
5996                                                                             ctx,
5997                                                                             &pattern13_0,
5998                                                                         );
5999                                                                         let expr1_0 =
6000                                                                             constructor_to_amode(
6001                                                                                 ctx,
6002                                                                                 pattern16_2,
6003                                                                                 pattern16_1,
6004                                                                                 pattern16_3,
6005                                                                             )?;
6006                                                                         let expr2_0 =
6007                                                                             constructor_put_in_gpr(
6008                                                                                 ctx,
6009                                                                                 pattern12_1,
6010                                                                             )?;
6011                                                                         let expr3_0 = constructor_x64_and_mem(ctx, pattern8_0, &expr1_0, expr2_0)?;
6012                                                                         let expr4_0 = constructor_side_effect(ctx, &expr3_0)?;
6013                                                                         return Some(expr4_0);
6014                                                                     }
6015                                                                 }
6016                                                             }
6017                                                         }
6018                                                     }
6019                                                 }
6020                                             }
6021                                             if let Some(pattern13_0) =
6022                                                 C::sinkable_load(ctx, pattern12_1)
6023                                             {
6024                                                 if let Some(pattern14_0) =
6025                                                     C::def_inst(ctx, pattern12_1)
6026                                                 {
6027                                                     let pattern15_0 =
6028                                                         C::inst_data(ctx, pattern14_0);
6029                                                     if let &InstructionData::Load {
6030                                                         opcode: ref pattern16_0,
6031                                                         arg: pattern16_1,
6032                                                         flags: pattern16_2,
6033                                                         offset: pattern16_3,
6034                                                     } = &pattern15_0
6035                                                     {
6036                                                         if let &Opcode::Load = pattern16_0 {
6037                                                             if pattern4_1 == pattern16_1 {
6038                                                                 if pattern2_2 == pattern16_2 {
6039                                                                     if pattern2_3 == pattern16_3 {
6040                                                                         // Rule at src/isa/x64/lower.isle line 2718.
6041                                                                         let expr0_0 = C::sink_load(
6042                                                                             ctx,
6043                                                                             &pattern13_0,
6044                                                                         );
6045                                                                         let expr1_0 =
6046                                                                             constructor_to_amode(
6047                                                                                 ctx,
6048                                                                                 pattern16_2,
6049                                                                                 pattern16_1,
6050                                                                                 pattern16_3,
6051                                                                             )?;
6052                                                                         let expr2_0 =
6053                                                                             constructor_put_in_gpr(
6054                                                                                 ctx,
6055                                                                                 pattern12_0,
6056                                                                             )?;
6057                                                                         let expr3_0 = constructor_x64_and_mem(ctx, pattern8_0, &expr1_0, expr2_0)?;
6058                                                                         let expr4_0 = constructor_side_effect(ctx, &expr3_0)?;
6059                                                                         return Some(expr4_0);
6060                                                                     }
6061                                                                 }
6062                                                             }
6063                                                         }
6064                                                     }
6065                                                 }
6066                                             }
6067                                         }
6068                                         &Opcode::Bor => {
6069                                             let (pattern12_0, pattern12_1) =
6070                                                 C::unpack_value_array_2(ctx, pattern10_1);
6071                                             if let Some(pattern13_0) =
6072                                                 C::sinkable_load(ctx, pattern12_0)
6073                                             {
6074                                                 if let Some(pattern14_0) =
6075                                                     C::def_inst(ctx, pattern12_0)
6076                                                 {
6077                                                     let pattern15_0 =
6078                                                         C::inst_data(ctx, pattern14_0);
6079                                                     if let &InstructionData::Load {
6080                                                         opcode: ref pattern16_0,
6081                                                         arg: pattern16_1,
6082                                                         flags: pattern16_2,
6083                                                         offset: pattern16_3,
6084                                                     } = &pattern15_0
6085                                                     {
6086                                                         if let &Opcode::Load = pattern16_0 {
6087                                                             if pattern4_1 == pattern16_1 {
6088                                                                 if pattern2_2 == pattern16_2 {
6089                                                                     if pattern2_3 == pattern16_3 {
6090                                                                         // Rule at src/isa/x64/lower.isle line 2732.
6091                                                                         let expr0_0 = C::sink_load(
6092                                                                             ctx,
6093                                                                             &pattern13_0,
6094                                                                         );
6095                                                                         let expr1_0 =
6096                                                                             constructor_to_amode(
6097                                                                                 ctx,
6098                                                                                 pattern16_2,
6099                                                                                 pattern16_1,
6100                                                                                 pattern16_3,
6101                                                                             )?;
6102                                                                         let expr2_0 =
6103                                                                             constructor_put_in_gpr(
6104                                                                                 ctx,
6105                                                                                 pattern12_1,
6106                                                                             )?;
6107                                                                         let expr3_0 =
6108                                                                             constructor_x64_or_mem(
6109                                                                                 ctx, pattern8_0,
6110                                                                                 &expr1_0, expr2_0,
6111                                                                             )?;
6112                                                                         let expr4_0 = constructor_side_effect(ctx, &expr3_0)?;
6113                                                                         return Some(expr4_0);
6114                                                                     }
6115                                                                 }
6116                                                             }
6117                                                         }
6118                                                     }
6119                                                 }
6120                                             }
6121                                             if let Some(pattern13_0) =
6122                                                 C::sinkable_load(ctx, pattern12_1)
6123                                             {
6124                                                 if let Some(pattern14_0) =
6125                                                     C::def_inst(ctx, pattern12_1)
6126                                                 {
6127                                                     let pattern15_0 =
6128                                                         C::inst_data(ctx, pattern14_0);
6129                                                     if let &InstructionData::Load {
6130                                                         opcode: ref pattern16_0,
6131                                                         arg: pattern16_1,
6132                                                         flags: pattern16_2,
6133                                                         offset: pattern16_3,
6134                                                     } = &pattern15_0
6135                                                     {
6136                                                         if let &Opcode::Load = pattern16_0 {
6137                                                             if pattern4_1 == pattern16_1 {
6138                                                                 if pattern2_2 == pattern16_2 {
6139                                                                     if pattern2_3 == pattern16_3 {
6140                                                                         // Rule at src/isa/x64/lower.isle line 2746.
6141                                                                         let expr0_0 = C::sink_load(
6142                                                                             ctx,
6143                                                                             &pattern13_0,
6144                                                                         );
6145                                                                         let expr1_0 =
6146                                                                             constructor_to_amode(
6147                                                                                 ctx,
6148                                                                                 pattern16_2,
6149                                                                                 pattern16_1,
6150                                                                                 pattern16_3,
6151                                                                             )?;
6152                                                                         let expr2_0 =
6153                                                                             constructor_put_in_gpr(
6154                                                                                 ctx,
6155                                                                                 pattern12_0,
6156                                                                             )?;
6157                                                                         let expr3_0 =
6158                                                                             constructor_x64_or_mem(
6159                                                                                 ctx, pattern8_0,
6160                                                                                 &expr1_0, expr2_0,
6161                                                                             )?;
6162                                                                         let expr4_0 = constructor_side_effect(ctx, &expr3_0)?;
6163                                                                         return Some(expr4_0);
6164                                                                     }
6165                                                                 }
6166                                                             }
6167                                                         }
6168                                                     }
6169                                                 }
6170                                             }
6171                                         }
6172                                         &Opcode::Bxor => {
6173                                             let (pattern12_0, pattern12_1) =
6174                                                 C::unpack_value_array_2(ctx, pattern10_1);
6175                                             if let Some(pattern13_0) =
6176                                                 C::sinkable_load(ctx, pattern12_0)
6177                                             {
6178                                                 if let Some(pattern14_0) =
6179                                                     C::def_inst(ctx, pattern12_0)
6180                                                 {
6181                                                     let pattern15_0 =
6182                                                         C::inst_data(ctx, pattern14_0);
6183                                                     if let &InstructionData::Load {
6184                                                         opcode: ref pattern16_0,
6185                                                         arg: pattern16_1,
6186                                                         flags: pattern16_2,
6187                                                         offset: pattern16_3,
6188                                                     } = &pattern15_0
6189                                                     {
6190                                                         if let &Opcode::Load = pattern16_0 {
6191                                                             if pattern4_1 == pattern16_1 {
6192                                                                 if pattern2_2 == pattern16_2 {
6193                                                                     if pattern2_3 == pattern16_3 {
6194                                                                         // Rule at src/isa/x64/lower.isle line 2760.
6195                                                                         let expr0_0 = C::sink_load(
6196                                                                             ctx,
6197                                                                             &pattern13_0,
6198                                                                         );
6199                                                                         let expr1_0 =
6200                                                                             constructor_to_amode(
6201                                                                                 ctx,
6202                                                                                 pattern16_2,
6203                                                                                 pattern16_1,
6204                                                                                 pattern16_3,
6205                                                                             )?;
6206                                                                         let expr2_0 =
6207                                                                             constructor_put_in_gpr(
6208                                                                                 ctx,
6209                                                                                 pattern12_1,
6210                                                                             )?;
6211                                                                         let expr3_0 = constructor_x64_xor_mem(ctx, pattern8_0, &expr1_0, expr2_0)?;
6212                                                                         let expr4_0 = constructor_side_effect(ctx, &expr3_0)?;
6213                                                                         return Some(expr4_0);
6214                                                                     }
6215                                                                 }
6216                                                             }
6217                                                         }
6218                                                     }
6219                                                 }
6220                                             }
6221                                             if let Some(pattern13_0) =
6222                                                 C::sinkable_load(ctx, pattern12_1)
6223                                             {
6224                                                 if let Some(pattern14_0) =
6225                                                     C::def_inst(ctx, pattern12_1)
6226                                                 {
6227                                                     let pattern15_0 =
6228                                                         C::inst_data(ctx, pattern14_0);
6229                                                     if let &InstructionData::Load {
6230                                                         opcode: ref pattern16_0,
6231                                                         arg: pattern16_1,
6232                                                         flags: pattern16_2,
6233                                                         offset: pattern16_3,
6234                                                     } = &pattern15_0
6235                                                     {
6236                                                         if let &Opcode::Load = pattern16_0 {
6237                                                             if pattern4_1 == pattern16_1 {
6238                                                                 if pattern2_2 == pattern16_2 {
6239                                                                     if pattern2_3 == pattern16_3 {
6240                                                                         // Rule at src/isa/x64/lower.isle line 2774.
6241                                                                         let expr0_0 = C::sink_load(
6242                                                                             ctx,
6243                                                                             &pattern13_0,
6244                                                                         );
6245                                                                         let expr1_0 =
6246                                                                             constructor_to_amode(
6247                                                                                 ctx,
6248                                                                                 pattern16_2,
6249                                                                                 pattern16_1,
6250                                                                                 pattern16_3,
6251                                                                             )?;
6252                                                                         let expr2_0 =
6253                                                                             constructor_put_in_gpr(
6254                                                                                 ctx,
6255                                                                                 pattern12_0,
6256                                                                             )?;
6257                                                                         let expr3_0 = constructor_x64_xor_mem(ctx, pattern8_0, &expr1_0, expr2_0)?;
6258                                                                         let expr4_0 = constructor_side_effect(ctx, &expr3_0)?;
6259                                                                         return Some(expr4_0);
6260                                                                     }
6261                                                                 }
6262                                                             }
6263                                                         }
6264                                                     }
6265                                                 }
6266                                             }
6267                                         }
6268                                         _ => {}
6269                                     }
6270                                 }
6271                             }
6272                         }
6273                     }
6274                     let pattern5_0 = C::value_type(ctx, pattern4_0);
6275                     if pattern5_0 == F32 {
6276                         // Rule at src/isa/x64/lower.isle line 2605.
6277                         let expr0_0 = SseOpcode::Movss;
6278                         let expr1_0 =
6279                             constructor_to_amode(ctx, pattern2_2, pattern4_1, pattern2_3)?;
6280                         let expr2_0 = C::amode_to_synthetic_amode(ctx, &expr1_0);
6281                         let expr3_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
6282                         let expr4_0 = constructor_x64_xmm_movrm(ctx, &expr0_0, &expr2_0, expr3_0)?;
6283                         let expr5_0 = constructor_side_effect(ctx, &expr4_0)?;
6284                         return Some(expr5_0);
6285                     }
6286                     if pattern5_0 == F64 {
6287                         // Rule at src/isa/x64/lower.isle line 2613.
6288                         let expr0_0 = SseOpcode::Movsd;
6289                         let expr1_0 =
6290                             constructor_to_amode(ctx, pattern2_2, pattern4_1, pattern2_3)?;
6291                         let expr2_0 = C::amode_to_synthetic_amode(ctx, &expr1_0);
6292                         let expr3_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
6293                         let expr4_0 = constructor_x64_xmm_movrm(ctx, &expr0_0, &expr2_0, expr3_0)?;
6294                         let expr5_0 = constructor_side_effect(ctx, &expr4_0)?;
6295                         return Some(expr5_0);
6296                     }
6297                     if pattern5_0 == F32X4 {
6298                         // Rule at src/isa/x64/lower.isle line 2621.
6299                         let expr0_0 = SseOpcode::Movups;
6300                         let expr1_0 =
6301                             constructor_to_amode(ctx, pattern2_2, pattern4_1, pattern2_3)?;
6302                         let expr2_0 = C::amode_to_synthetic_amode(ctx, &expr1_0);
6303                         let expr3_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
6304                         let expr4_0 = constructor_x64_xmm_movrm(ctx, &expr0_0, &expr2_0, expr3_0)?;
6305                         let expr5_0 = constructor_side_effect(ctx, &expr4_0)?;
6306                         return Some(expr5_0);
6307                     }
6308                     if pattern5_0 == F64X2 {
6309                         // Rule at src/isa/x64/lower.isle line 2629.
6310                         let expr0_0 = SseOpcode::Movupd;
6311                         let expr1_0 =
6312                             constructor_to_amode(ctx, pattern2_2, pattern4_1, pattern2_3)?;
6313                         let expr2_0 = C::amode_to_synthetic_amode(ctx, &expr1_0);
6314                         let expr3_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
6315                         let expr4_0 = constructor_x64_xmm_movrm(ctx, &expr0_0, &expr2_0, expr3_0)?;
6316                         let expr5_0 = constructor_side_effect(ctx, &expr4_0)?;
6317                         return Some(expr5_0);
6318                     }
6319                     if let Some(pattern6_0) = C::ty_int_bool_128(ctx, pattern5_0) {
6320                         // Rule at src/isa/x64/lower.isle line 2645.
6321                         let expr0_0 = C::put_in_regs(ctx, pattern4_0);
6322                         let expr1_0: usize = 0;
6323                         let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?;
6324                         let expr3_0: usize = 1;
6325                         let expr4_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr3_0)?;
6326                         let expr5_0 =
6327                             constructor_to_amode(ctx, pattern2_2, pattern4_1, pattern2_3)?;
6328                         let expr6_0: u32 = 8;
6329                         let expr7_0 = C::amode_offset(ctx, &expr5_0, expr6_0);
6330                         let expr8_0: Type = I64;
6331                         let expr9_0 = C::amode_to_synthetic_amode(ctx, &expr5_0);
6332                         let expr10_0 = constructor_x64_movrm(ctx, expr8_0, &expr9_0, expr2_0)?;
6333                         let expr11_0: Type = I64;
6334                         let expr12_0 = C::amode_to_synthetic_amode(ctx, &expr7_0);
6335                         let expr13_0 = constructor_x64_movrm(ctx, expr11_0, &expr12_0, expr4_0)?;
6336                         let expr14_0 = constructor_side_effect_concat(ctx, &expr10_0, &expr13_0)?;
6337                         let expr15_0 = constructor_side_effect(ctx, &expr14_0)?;
6338                         return Some(expr15_0);
6339                     }
6340                     if let Some(pattern6_0) = C::ty_vec128_int(ctx, pattern5_0) {
6341                         // Rule at src/isa/x64/lower.isle line 2637.
6342                         let expr0_0 = SseOpcode::Movdqu;
6343                         let expr1_0 =
6344                             constructor_to_amode(ctx, pattern2_2, pattern4_1, pattern2_3)?;
6345                         let expr2_0 = C::amode_to_synthetic_amode(ctx, &expr1_0);
6346                         let expr3_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
6347                         let expr4_0 = constructor_x64_xmm_movrm(ctx, &expr0_0, &expr2_0, expr3_0)?;
6348                         let expr5_0 = constructor_side_effect(ctx, &expr4_0)?;
6349                         return Some(expr5_0);
6350                     }
6351                     if let Some(pattern6_0) = C::is_gpr_type(ctx, pattern5_0) {
6352                         // Rule at src/isa/x64/lower.isle line 2586.
6353                         let expr0_0 =
6354                             constructor_to_amode(ctx, pattern2_2, pattern4_1, pattern2_3)?;
6355                         let expr1_0 = C::amode_to_synthetic_amode(ctx, &expr0_0);
6356                         let expr2_0 = constructor_put_in_gpr(ctx, pattern4_0)?;
6357                         let expr3_0 = constructor_x64_movrm(ctx, pattern6_0, &expr1_0, expr2_0)?;
6358                         let expr4_0 = constructor_side_effect(ctx, &expr3_0)?;
6359                         return Some(expr4_0);
6360                     }
6361                 }
6362                 &Opcode::Istore8 => {
6363                     let (pattern4_0, pattern4_1) = C::unpack_value_array_2(ctx, pattern2_1);
6364                     // Rule at src/isa/x64/lower.isle line 2594.
6365                     let expr0_0: Type = I8;
6366                     let expr1_0 = constructor_to_amode(ctx, pattern2_2, pattern4_1, pattern2_3)?;
6367                     let expr2_0 = C::amode_to_synthetic_amode(ctx, &expr1_0);
6368                     let expr3_0 = constructor_put_in_gpr(ctx, pattern4_0)?;
6369                     let expr4_0 = constructor_x64_movrm(ctx, expr0_0, &expr2_0, expr3_0)?;
6370                     let expr5_0 = constructor_side_effect(ctx, &expr4_0)?;
6371                     return Some(expr5_0);
6372                 }
6373                 &Opcode::Istore16 => {
6374                     let (pattern4_0, pattern4_1) = C::unpack_value_array_2(ctx, pattern2_1);
6375                     // Rule at src/isa/x64/lower.isle line 2597.
6376                     let expr0_0: Type = I16;
6377                     let expr1_0 = constructor_to_amode(ctx, pattern2_2, pattern4_1, pattern2_3)?;
6378                     let expr2_0 = C::amode_to_synthetic_amode(ctx, &expr1_0);
6379                     let expr3_0 = constructor_put_in_gpr(ctx, pattern4_0)?;
6380                     let expr4_0 = constructor_x64_movrm(ctx, expr0_0, &expr2_0, expr3_0)?;
6381                     let expr5_0 = constructor_side_effect(ctx, &expr4_0)?;
6382                     return Some(expr5_0);
6383                 }
6384                 &Opcode::Istore32 => {
6385                     let (pattern4_0, pattern4_1) = C::unpack_value_array_2(ctx, pattern2_1);
6386                     // Rule at src/isa/x64/lower.isle line 2600.
6387                     let expr0_0: Type = I32;
6388                     let expr1_0 = constructor_to_amode(ctx, pattern2_2, pattern4_1, pattern2_3)?;
6389                     let expr2_0 = C::amode_to_synthetic_amode(ctx, &expr1_0);
6390                     let expr3_0 = constructor_put_in_gpr(ctx, pattern4_0)?;
6391                     let expr4_0 = constructor_x64_movrm(ctx, expr0_0, &expr2_0, expr3_0)?;
6392                     let expr5_0 = constructor_side_effect(ctx, &expr4_0)?;
6393                     return Some(expr5_0);
6394                 }
6395                 _ => {}
6396             }
6397         }
6398         &InstructionData::TernaryImm8 {
6399             opcode: ref pattern2_0,
6400             args: ref pattern2_1,
6401             imm: pattern2_2,
6402         } => {
6403             if let &Opcode::Insertlane = pattern2_0 {
6404                 let (pattern4_0, pattern4_1) = C::unpack_value_array_2(ctx, pattern2_1);
6405                 let pattern5_0 = C::value_type(ctx, pattern4_0);
6406                 let pattern6_0 = C::u8_from_uimm8(ctx, pattern2_2);
6407                 // Rule at src/isa/x64/lower.isle line 1302.
6408                 let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
6409                 let expr1_0 = C::put_in_reg_mem(ctx, pattern4_1);
6410                 let expr2_0 =
6411                     constructor_vec_insert_lane(ctx, pattern5_0, expr0_0, &expr1_0, pattern6_0)?;
6412                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
6413                 return Some(expr3_0);
6414             }
6415         }
6416         &InstructionData::FloatCompare {
6417             opcode: ref pattern2_0,
6418             args: ref pattern2_1,
6419             cond: ref pattern2_2,
6420         } => {
6421             if let &Opcode::Fcmp = pattern2_0 {
6422                 let (pattern4_0, pattern4_1) = C::unpack_value_array_2(ctx, pattern2_1);
6423                 let pattern5_0 = C::value_type(ctx, pattern4_0);
6424                 if let Some(pattern6_0) = C::ty_scalar_float(ctx, pattern5_0) {
6425                     match pattern2_2 {
6426                         &FloatCC::Equal => {
6427                             // Rule at src/isa/x64/lower.isle line 1575.
6428                             let expr0_0 = constructor_x64_ucomis(ctx, pattern4_1, pattern4_0)?;
6429                             let expr1_0 = CC::NP;
6430                             let expr2_0 = constructor_x64_setcc(ctx, &expr1_0)?;
6431                             let expr3_0 = CC::Z;
6432                             let expr4_0 = constructor_x64_setcc(ctx, &expr3_0)?;
6433                             let expr5_0 =
6434                                 constructor_consumes_flags_concat(ctx, &expr2_0, &expr4_0)?;
6435                             let expr6_0 = constructor_with_flags(ctx, &expr0_0, &expr5_0)?;
6436                             let expr7_0: usize = 0;
6437                             let expr8_0 = constructor_value_regs_get_gpr(ctx, expr6_0, expr7_0)?;
6438                             let expr9_0: usize = 1;
6439                             let expr10_0 = constructor_value_regs_get_gpr(ctx, expr6_0, expr9_0)?;
6440                             let expr11_0: Type = I32;
6441                             let expr12_0 = C::gpr_to_gpr_mem_imm(ctx, expr10_0);
6442                             let expr13_0 = constructor_x64_and(ctx, expr11_0, expr8_0, &expr12_0)?;
6443                             let expr14_0 = constructor_output_gpr(ctx, expr13_0)?;
6444                             return Some(expr14_0);
6445                         }
6446                         &FloatCC::GreaterThan => {
6447                             // Rule at src/isa/x64/lower.isle line 1603.
6448                             let expr0_0 = constructor_x64_ucomis(ctx, pattern4_1, pattern4_0)?;
6449                             let expr1_0 = CC::NBE;
6450                             let expr2_0 = constructor_x64_setcc(ctx, &expr1_0)?;
6451                             let expr3_0 = constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
6452                             let expr4_0 = C::output(ctx, expr3_0);
6453                             return Some(expr4_0);
6454                         }
6455                         &FloatCC::GreaterThanOrEqual => {
6456                             // Rule at src/isa/x64/lower.isle line 1605.
6457                             let expr0_0 = constructor_x64_ucomis(ctx, pattern4_1, pattern4_0)?;
6458                             let expr1_0 = CC::NB;
6459                             let expr2_0 = constructor_x64_setcc(ctx, &expr1_0)?;
6460                             let expr3_0 = constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
6461                             let expr4_0 = C::output(ctx, expr3_0);
6462                             return Some(expr4_0);
6463                         }
6464                         &FloatCC::LessThan => {
6465                             // Rule at src/isa/x64/lower.isle line 1615.
6466                             let expr0_0 = constructor_x64_ucomis(ctx, pattern4_0, pattern4_1)?;
6467                             let expr1_0 = CC::NBE;
6468                             let expr2_0 = constructor_x64_setcc(ctx, &expr1_0)?;
6469                             let expr3_0 = constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
6470                             let expr4_0 = C::output(ctx, expr3_0);
6471                             return Some(expr4_0);
6472                         }
6473                         &FloatCC::LessThanOrEqual => {
6474                             // Rule at src/isa/x64/lower.isle line 1618.
6475                             let expr0_0 = constructor_x64_ucomis(ctx, pattern4_0, pattern4_1)?;
6476                             let expr1_0 = CC::NB;
6477                             let expr2_0 = constructor_x64_setcc(ctx, &expr1_0)?;
6478                             let expr3_0 = constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
6479                             let expr4_0 = C::output(ctx, expr3_0);
6480                             return Some(expr4_0);
6481                         }
6482                         &FloatCC::NotEqual => {
6483                             // Rule at src/isa/x64/lower.isle line 1584.
6484                             let expr0_0 = constructor_x64_ucomis(ctx, pattern4_1, pattern4_0)?;
6485                             let expr1_0 = CC::P;
6486                             let expr2_0 = constructor_x64_setcc(ctx, &expr1_0)?;
6487                             let expr3_0 = CC::NZ;
6488                             let expr4_0 = constructor_x64_setcc(ctx, &expr3_0)?;
6489                             let expr5_0 =
6490                                 constructor_consumes_flags_concat(ctx, &expr2_0, &expr4_0)?;
6491                             let expr6_0 = constructor_with_flags(ctx, &expr0_0, &expr5_0)?;
6492                             let expr7_0: usize = 0;
6493                             let expr8_0 = constructor_value_regs_get_gpr(ctx, expr6_0, expr7_0)?;
6494                             let expr9_0: usize = 1;
6495                             let expr10_0 = constructor_value_regs_get_gpr(ctx, expr6_0, expr9_0)?;
6496                             let expr11_0: Type = I32;
6497                             let expr12_0 = C::gpr_to_gpr_mem_imm(ctx, expr10_0);
6498                             let expr13_0 = constructor_x64_or(ctx, expr11_0, expr8_0, &expr12_0)?;
6499                             let expr14_0 = constructor_output_gpr(ctx, expr13_0)?;
6500                             return Some(expr14_0);
6501                         }
6502                         &FloatCC::Ordered => {
6503                             // Rule at src/isa/x64/lower.isle line 1595.
6504                             let expr0_0 = constructor_x64_ucomis(ctx, pattern4_1, pattern4_0)?;
6505                             let expr1_0 = CC::NP;
6506                             let expr2_0 = constructor_x64_setcc(ctx, &expr1_0)?;
6507                             let expr3_0 = constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
6508                             let expr4_0 = C::output(ctx, expr3_0);
6509                             return Some(expr4_0);
6510                         }
6511                         &FloatCC::OrderedNotEqual => {
6512                             // Rule at src/isa/x64/lower.isle line 1599.
6513                             let expr0_0 = constructor_x64_ucomis(ctx, pattern4_1, pattern4_0)?;
6514                             let expr1_0 = CC::NZ;
6515                             let expr2_0 = constructor_x64_setcc(ctx, &expr1_0)?;
6516                             let expr3_0 = constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
6517                             let expr4_0 = C::output(ctx, expr3_0);
6518                             return Some(expr4_0);
6519                         }
6520                         &FloatCC::Unordered => {
6521                             // Rule at src/isa/x64/lower.isle line 1597.
6522                             let expr0_0 = constructor_x64_ucomis(ctx, pattern4_1, pattern4_0)?;
6523                             let expr1_0 = CC::P;
6524                             let expr2_0 = constructor_x64_setcc(ctx, &expr1_0)?;
6525                             let expr3_0 = constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
6526                             let expr4_0 = C::output(ctx, expr3_0);
6527                             return Some(expr4_0);
6528                         }
6529                         &FloatCC::UnorderedOrEqual => {
6530                             // Rule at src/isa/x64/lower.isle line 1601.
6531                             let expr0_0 = constructor_x64_ucomis(ctx, pattern4_1, pattern4_0)?;
6532                             let expr1_0 = CC::Z;
6533                             let expr2_0 = constructor_x64_setcc(ctx, &expr1_0)?;
6534                             let expr3_0 = constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
6535                             let expr4_0 = C::output(ctx, expr3_0);
6536                             return Some(expr4_0);
6537                         }
6538                         &FloatCC::UnorderedOrGreaterThan => {
6539                             // Rule at src/isa/x64/lower.isle line 1621.
6540                             let expr0_0 = constructor_x64_ucomis(ctx, pattern4_0, pattern4_1)?;
6541                             let expr1_0 = CC::B;
6542                             let expr2_0 = constructor_x64_setcc(ctx, &expr1_0)?;
6543                             let expr3_0 = constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
6544                             let expr4_0 = C::output(ctx, expr3_0);
6545                             return Some(expr4_0);
6546                         }
6547                         &FloatCC::UnorderedOrGreaterThanOrEqual => {
6548                             // Rule at src/isa/x64/lower.isle line 1624.
6549                             let expr0_0 = constructor_x64_ucomis(ctx, pattern4_0, pattern4_1)?;
6550                             let expr1_0 = CC::BE;
6551                             let expr2_0 = constructor_x64_setcc(ctx, &expr1_0)?;
6552                             let expr3_0 = constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
6553                             let expr4_0 = C::output(ctx, expr3_0);
6554                             return Some(expr4_0);
6555                         }
6556                         &FloatCC::UnorderedOrLessThan => {
6557                             // Rule at src/isa/x64/lower.isle line 1607.
6558                             let expr0_0 = constructor_x64_ucomis(ctx, pattern4_1, pattern4_0)?;
6559                             let expr1_0 = CC::B;
6560                             let expr2_0 = constructor_x64_setcc(ctx, &expr1_0)?;
6561                             let expr3_0 = constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
6562                             let expr4_0 = C::output(ctx, expr3_0);
6563                             return Some(expr4_0);
6564                         }
6565                         &FloatCC::UnorderedOrLessThanOrEqual => {
6566                             // Rule at src/isa/x64/lower.isle line 1609.
6567                             let expr0_0 = constructor_x64_ucomis(ctx, pattern4_1, pattern4_0)?;
6568                             let expr1_0 = CC::BE;
6569                             let expr2_0 = constructor_x64_setcc(ctx, &expr1_0)?;
6570                             let expr3_0 = constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
6571                             let expr4_0 = C::output(ctx, expr3_0);
6572                             return Some(expr4_0);
6573                         }
6574                         _ => {}
6575                     }
6576                 }
6577                 if let Some(pattern6_0) = C::ty_vec128(ctx, pattern5_0) {
6578                     match pattern2_2 {
6579                         &FloatCC::Equal => {
6580                             // Rule at src/isa/x64/lower.isle line 1632.
6581                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
6582                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?;
6583                             let expr2_0 = FcmpImm::Equal;
6584                             let expr3_0 =
6585                                 constructor_x64_cmpp(ctx, pattern6_0, expr0_0, &expr1_0, &expr2_0)?;
6586                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
6587                             return Some(expr4_0);
6588                         }
6589                         &FloatCC::GreaterThan => {
6590                             // Rule at src/isa/x64/lower.isle line 1652.
6591                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_1)?;
6592                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_0)?;
6593                             let expr2_0 = FcmpImm::LessThan;
6594                             let expr3_0 =
6595                                 constructor_x64_cmpp(ctx, pattern6_0, expr0_0, &expr1_0, &expr2_0)?;
6596                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
6597                             return Some(expr4_0);
6598                         }
6599                         &FloatCC::GreaterThanOrEqual => {
6600                             // Rule at src/isa/x64/lower.isle line 1654.
6601                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_1)?;
6602                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_0)?;
6603                             let expr2_0 = FcmpImm::LessThanOrEqual;
6604                             let expr3_0 =
6605                                 constructor_x64_cmpp(ctx, pattern6_0, expr0_0, &expr1_0, &expr2_0)?;
6606                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
6607                             return Some(expr4_0);
6608                         }
6609                         &FloatCC::LessThan => {
6610                             // Rule at src/isa/x64/lower.isle line 1636.
6611                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
6612                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?;
6613                             let expr2_0 = FcmpImm::LessThan;
6614                             let expr3_0 =
6615                                 constructor_x64_cmpp(ctx, pattern6_0, expr0_0, &expr1_0, &expr2_0)?;
6616                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
6617                             return Some(expr4_0);
6618                         }
6619                         &FloatCC::LessThanOrEqual => {
6620                             // Rule at src/isa/x64/lower.isle line 1638.
6621                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
6622                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?;
6623                             let expr2_0 = FcmpImm::LessThanOrEqual;
6624                             let expr3_0 =
6625                                 constructor_x64_cmpp(ctx, pattern6_0, expr0_0, &expr1_0, &expr2_0)?;
6626                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
6627                             return Some(expr4_0);
6628                         }
6629                         &FloatCC::NotEqual => {
6630                             // Rule at src/isa/x64/lower.isle line 1634.
6631                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
6632                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?;
6633                             let expr2_0 = FcmpImm::NotEqual;
6634                             let expr3_0 =
6635                                 constructor_x64_cmpp(ctx, pattern6_0, expr0_0, &expr1_0, &expr2_0)?;
6636                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
6637                             return Some(expr4_0);
6638                         }
6639                         &FloatCC::Ordered => {
6640                             // Rule at src/isa/x64/lower.isle line 1640.
6641                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
6642                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?;
6643                             let expr2_0 = FcmpImm::Ordered;
6644                             let expr3_0 =
6645                                 constructor_x64_cmpp(ctx, pattern6_0, expr0_0, &expr1_0, &expr2_0)?;
6646                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
6647                             return Some(expr4_0);
6648                         }
6649                         &FloatCC::Unordered => {
6650                             // Rule at src/isa/x64/lower.isle line 1642.
6651                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
6652                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?;
6653                             let expr2_0 = FcmpImm::Unordered;
6654                             let expr3_0 =
6655                                 constructor_x64_cmpp(ctx, pattern6_0, expr0_0, &expr1_0, &expr2_0)?;
6656                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
6657                             return Some(expr4_0);
6658                         }
6659                         &FloatCC::UnorderedOrGreaterThan => {
6660                             // Rule at src/isa/x64/lower.isle line 1644.
6661                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
6662                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?;
6663                             let expr2_0 = FcmpImm::UnorderedOrGreaterThan;
6664                             let expr3_0 =
6665                                 constructor_x64_cmpp(ctx, pattern6_0, expr0_0, &expr1_0, &expr2_0)?;
6666                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
6667                             return Some(expr4_0);
6668                         }
6669                         &FloatCC::UnorderedOrGreaterThanOrEqual => {
6670                             // Rule at src/isa/x64/lower.isle line 1646.
6671                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
6672                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?;
6673                             let expr2_0 = FcmpImm::UnorderedOrGreaterThanOrEqual;
6674                             let expr3_0 =
6675                                 constructor_x64_cmpp(ctx, pattern6_0, expr0_0, &expr1_0, &expr2_0)?;
6676                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
6677                             return Some(expr4_0);
6678                         }
6679                         &FloatCC::UnorderedOrLessThan => {
6680                             // Rule at src/isa/x64/lower.isle line 1656.
6681                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_1)?;
6682                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_0)?;
6683                             let expr2_0 = FcmpImm::UnorderedOrGreaterThan;
6684                             let expr3_0 =
6685                                 constructor_x64_cmpp(ctx, pattern6_0, expr0_0, &expr1_0, &expr2_0)?;
6686                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
6687                             return Some(expr4_0);
6688                         }
6689                         &FloatCC::UnorderedOrLessThanOrEqual => {
6690                             // Rule at src/isa/x64/lower.isle line 1658.
6691                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_1)?;
6692                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_0)?;
6693                             let expr2_0 = FcmpImm::UnorderedOrGreaterThanOrEqual;
6694                             let expr3_0 =
6695                                 constructor_x64_cmpp(ctx, pattern6_0, expr0_0, &expr1_0, &expr2_0)?;
6696                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
6697                             return Some(expr4_0);
6698                         }
6699                         _ => {}
6700                     }
6701                 }
6702             }
6703         }
6704         &InstructionData::IntCompare {
6705             opcode: ref pattern2_0,
6706             args: ref pattern2_1,
6707             cond: ref pattern2_2,
6708         } => {
6709             if let &Opcode::Icmp = pattern2_0 {
6710                 let (pattern4_0, pattern4_1) = C::unpack_value_array_2(ctx, pattern2_1);
6711                 let pattern5_0 = C::value_type(ctx, pattern4_0);
6712                 if pattern5_0 == I128 {
6713                     match pattern2_2 {
6714                         &IntCC::Equal => {
6715                             // Rule at src/isa/x64/lower.isle line 1526.
6716                             let expr0_0 = C::put_in_regs(ctx, pattern4_0);
6717                             let expr1_0: usize = 0;
6718                             let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?;
6719                             let expr3_0 = C::put_in_regs(ctx, pattern4_0);
6720                             let expr4_0: usize = 1;
6721                             let expr5_0 = constructor_value_regs_get_gpr(ctx, expr3_0, expr4_0)?;
6722                             let expr6_0 = C::put_in_regs(ctx, pattern4_1);
6723                             let expr7_0: usize = 0;
6724                             let expr8_0 = constructor_value_regs_get_gpr(ctx, expr6_0, expr7_0)?;
6725                             let expr9_0 = C::put_in_regs(ctx, pattern4_1);
6726                             let expr10_0: usize = 1;
6727                             let expr11_0 = constructor_value_regs_get_gpr(ctx, expr9_0, expr10_0)?;
6728                             let expr12_0 = OperandSize::Size64;
6729                             let expr13_0 = C::gpr_to_gpr_mem_imm(ctx, expr8_0);
6730                             let expr14_0 = constructor_x64_cmp(ctx, &expr12_0, &expr13_0, expr2_0)?;
6731                             let expr15_0 = CC::Z;
6732                             let expr16_0 = constructor_x64_setcc(ctx, &expr15_0)?;
6733                             let expr17_0 = constructor_with_flags_reg(ctx, &expr14_0, &expr16_0)?;
6734                             let expr18_0 = OperandSize::Size64;
6735                             let expr19_0 = C::gpr_to_gpr_mem_imm(ctx, expr11_0);
6736                             let expr20_0 = constructor_x64_cmp(ctx, &expr18_0, &expr19_0, expr5_0)?;
6737                             let expr21_0 = CC::Z;
6738                             let expr22_0 = constructor_x64_setcc(ctx, &expr21_0)?;
6739                             let expr23_0 = constructor_with_flags_reg(ctx, &expr20_0, &expr22_0)?;
6740                             let expr24_0: Type = I64;
6741                             let expr25_0 = C::gpr_new(ctx, expr17_0);
6742                             let expr26_0 = constructor_reg_to_gpr_mem_imm(ctx, expr23_0)?;
6743                             let expr27_0 = constructor_x64_and(ctx, expr24_0, expr25_0, &expr26_0)?;
6744                             let expr28_0 = C::gpr_to_reg(ctx, expr27_0);
6745                             let expr29_0 = OperandSize::Size64;
6746                             let expr30_0: u32 = 1;
6747                             let expr31_0 = RegMemImm::Imm { simm32: expr30_0 };
6748                             let expr32_0 = C::gpr_mem_imm_new(ctx, &expr31_0);
6749                             let expr33_0 = C::gpr_new(ctx, expr28_0);
6750                             let expr34_0 =
6751                                 constructor_x64_test(ctx, &expr29_0, &expr32_0, expr33_0)?;
6752                             let expr35_0 = CC::NZ;
6753                             let expr36_0 = constructor_x64_setcc(ctx, &expr35_0)?;
6754                             let expr37_0 = constructor_with_flags(ctx, &expr34_0, &expr36_0)?;
6755                             let expr38_0 = C::output(ctx, expr37_0);
6756                             return Some(expr38_0);
6757                         }
6758                         &IntCC::NotEqual => {
6759                             // Rule at src/isa/x64/lower.isle line 1545.
6760                             let expr0_0 = C::put_in_regs(ctx, pattern4_0);
6761                             let expr1_0: usize = 0;
6762                             let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?;
6763                             let expr3_0 = C::put_in_regs(ctx, pattern4_0);
6764                             let expr4_0: usize = 1;
6765                             let expr5_0 = constructor_value_regs_get_gpr(ctx, expr3_0, expr4_0)?;
6766                             let expr6_0 = C::put_in_regs(ctx, pattern4_1);
6767                             let expr7_0: usize = 0;
6768                             let expr8_0 = constructor_value_regs_get_gpr(ctx, expr6_0, expr7_0)?;
6769                             let expr9_0 = C::put_in_regs(ctx, pattern4_1);
6770                             let expr10_0: usize = 1;
6771                             let expr11_0 = constructor_value_regs_get_gpr(ctx, expr9_0, expr10_0)?;
6772                             let expr12_0 = OperandSize::Size64;
6773                             let expr13_0 = C::gpr_to_gpr_mem_imm(ctx, expr8_0);
6774                             let expr14_0 = constructor_x64_cmp(ctx, &expr12_0, &expr13_0, expr2_0)?;
6775                             let expr15_0 = CC::NZ;
6776                             let expr16_0 = constructor_x64_setcc(ctx, &expr15_0)?;
6777                             let expr17_0 = constructor_with_flags_reg(ctx, &expr14_0, &expr16_0)?;
6778                             let expr18_0 = OperandSize::Size64;
6779                             let expr19_0 = C::gpr_to_gpr_mem_imm(ctx, expr11_0);
6780                             let expr20_0 = constructor_x64_cmp(ctx, &expr18_0, &expr19_0, expr5_0)?;
6781                             let expr21_0 = CC::NZ;
6782                             let expr22_0 = constructor_x64_setcc(ctx, &expr21_0)?;
6783                             let expr23_0 = constructor_with_flags_reg(ctx, &expr20_0, &expr22_0)?;
6784                             let expr24_0: Type = I64;
6785                             let expr25_0 = C::gpr_new(ctx, expr17_0);
6786                             let expr26_0 = constructor_reg_to_gpr_mem_imm(ctx, expr23_0)?;
6787                             let expr27_0 = constructor_x64_or(ctx, expr24_0, expr25_0, &expr26_0)?;
6788                             let expr28_0 = C::gpr_to_reg(ctx, expr27_0);
6789                             let expr29_0 = OperandSize::Size64;
6790                             let expr30_0: u32 = 1;
6791                             let expr31_0 = RegMemImm::Imm { simm32: expr30_0 };
6792                             let expr32_0 = C::gpr_mem_imm_new(ctx, &expr31_0);
6793                             let expr33_0 = C::gpr_new(ctx, expr28_0);
6794                             let expr34_0 =
6795                                 constructor_x64_test(ctx, &expr29_0, &expr32_0, expr33_0)?;
6796                             let expr35_0 = CC::NZ;
6797                             let expr36_0 = constructor_x64_setcc(ctx, &expr35_0)?;
6798                             let expr37_0 = constructor_with_flags(ctx, &expr34_0, &expr36_0)?;
6799                             let expr38_0 = C::output(ctx, expr37_0);
6800                             return Some(expr38_0);
6801                         }
6802                         _ => {}
6803                     }
6804                 }
6805                 if pattern5_0 == I64X2 {
6806                     match pattern2_2 {
6807                         &IntCC::SignedGreaterThanOrEqual => {
6808                             // Rule at src/isa/x64/lower.isle line 1511.
6809                             let expr0_0: Type = I64X2;
6810                             let expr1_0 = constructor_put_in_xmm(ctx, pattern4_1)?;
6811                             let expr2_0 = constructor_put_in_xmm_mem(ctx, pattern4_0)?;
6812                             let expr3_0 = constructor_x64_pcmpgt(ctx, expr0_0, expr1_0, &expr2_0)?;
6813                             let expr4_0: Type = I64X2;
6814                             let expr5_0 = constructor_vector_all_ones(ctx, expr4_0)?;
6815                             let expr6_0 = C::xmm_to_xmm_mem(ctx, expr5_0);
6816                             let expr7_0 = constructor_x64_pxor(ctx, expr3_0, &expr6_0)?;
6817                             let expr8_0 = constructor_output_xmm(ctx, expr7_0)?;
6818                             return Some(expr8_0);
6819                         }
6820                         &IntCC::SignedLessThanOrEqual => {
6821                             // Rule at src/isa/x64/lower.isle line 1515.
6822                             let expr0_0: Type = I64X2;
6823                             let expr1_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
6824                             let expr2_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?;
6825                             let expr3_0 = constructor_x64_pcmpgt(ctx, expr0_0, expr1_0, &expr2_0)?;
6826                             let expr4_0: Type = I64X2;
6827                             let expr5_0 = constructor_vector_all_ones(ctx, expr4_0)?;
6828                             let expr6_0 = C::xmm_to_xmm_mem(ctx, expr5_0);
6829                             let expr7_0 = constructor_x64_pxor(ctx, expr3_0, &expr6_0)?;
6830                             let expr8_0 = constructor_output_xmm(ctx, expr7_0)?;
6831                             return Some(expr8_0);
6832                         }
6833                         _ => {}
6834                     }
6835                 }
6836                 if let Some(pattern6_0) = C::fits_in_64(ctx, pattern5_0) {
6837                     // Rule at src/isa/x64/lower.isle line 1451.
6838                     let expr0_0 = C::raw_operand_size_of_type(ctx, pattern6_0);
6839                     let expr1_0 = constructor_put_in_gpr_mem_imm(ctx, pattern4_1)?;
6840                     let expr2_0 = constructor_put_in_gpr(ctx, pattern4_0)?;
6841                     let expr3_0 = constructor_x64_cmp(ctx, &expr0_0, &expr1_0, expr2_0)?;
6842                     let expr4_0 = C::intcc_to_cc(ctx, pattern2_2);
6843                     let expr5_0 = constructor_x64_setcc(ctx, &expr4_0)?;
6844                     let expr6_0 = constructor_with_flags(ctx, &expr3_0, &expr5_0)?;
6845                     let expr7_0 = C::output(ctx, expr6_0);
6846                     return Some(expr7_0);
6847                 }
6848                 if let Some(pattern6_0) = C::ty_vec128(ctx, pattern5_0) {
6849                     match pattern2_2 {
6850                         &IntCC::Equal => {
6851                             // Rule at src/isa/x64/lower.isle line 1460.
6852                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
6853                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?;
6854                             let expr2_0 =
6855                                 constructor_x64_pcmpeq(ctx, pattern6_0, expr0_0, &expr1_0)?;
6856                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
6857                             return Some(expr3_0);
6858                         }
6859                         &IntCC::NotEqual => {
6860                             // Rule at src/isa/x64/lower.isle line 1464.
6861                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
6862                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?;
6863                             let expr2_0 =
6864                                 constructor_x64_pcmpeq(ctx, pattern6_0, expr0_0, &expr1_0)?;
6865                             let expr3_0 = constructor_vector_all_ones(ctx, pattern6_0)?;
6866                             let expr4_0 = C::xmm_to_xmm_mem(ctx, expr3_0);
6867                             let expr5_0 = constructor_x64_pxor(ctx, expr2_0, &expr4_0)?;
6868                             let expr6_0 = constructor_output_xmm(ctx, expr5_0)?;
6869                             return Some(expr6_0);
6870                         }
6871                         &IntCC::SignedGreaterThan => {
6872                             // Rule at src/isa/x64/lower.isle line 1471.
6873                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
6874                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?;
6875                             let expr2_0 =
6876                                 constructor_x64_pcmpgt(ctx, pattern6_0, expr0_0, &expr1_0)?;
6877                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
6878                             return Some(expr3_0);
6879                         }
6880                         &IntCC::SignedGreaterThanOrEqual => {
6881                             // Rule at src/isa/x64/lower.isle line 1496.
6882                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
6883                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?;
6884                             let expr2_0 =
6885                                 constructor_x64_pmaxs(ctx, pattern6_0, expr0_0, &expr1_0)?;
6886                             let expr3_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
6887                             let expr4_0 = C::xmm_to_xmm_mem(ctx, expr2_0);
6888                             let expr5_0 =
6889                                 constructor_x64_pcmpeq(ctx, pattern6_0, expr3_0, &expr4_0)?;
6890                             let expr6_0 = constructor_output_xmm(ctx, expr5_0)?;
6891                             return Some(expr6_0);
6892                         }
6893                         &IntCC::SignedLessThan => {
6894                             // Rule at src/isa/x64/lower.isle line 1473.
6895                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_1)?;
6896                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_0)?;
6897                             let expr2_0 =
6898                                 constructor_x64_pcmpgt(ctx, pattern6_0, expr0_0, &expr1_0)?;
6899                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
6900                             return Some(expr3_0);
6901                         }
6902                         &IntCC::SignedLessThanOrEqual => {
6903                             // Rule at src/isa/x64/lower.isle line 1499.
6904                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
6905                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?;
6906                             let expr2_0 =
6907                                 constructor_x64_pmins(ctx, pattern6_0, expr0_0, &expr1_0)?;
6908                             let expr3_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
6909                             let expr4_0 = C::xmm_to_xmm_mem(ctx, expr2_0);
6910                             let expr5_0 =
6911                                 constructor_x64_pcmpeq(ctx, pattern6_0, expr3_0, &expr4_0)?;
6912                             let expr6_0 = constructor_output_xmm(ctx, expr5_0)?;
6913                             return Some(expr6_0);
6914                         }
6915                         &IntCC::UnsignedGreaterThan => {
6916                             // Rule at src/isa/x64/lower.isle line 1475.
6917                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
6918                             let expr1_0 = constructor_put_in_xmm(ctx, pattern4_1)?;
6919                             let expr2_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
6920                             let expr3_0 =
6921                                 constructor_x64_pmaxu(ctx, pattern6_0, expr0_0, &expr2_0)?;
6922                             let expr4_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
6923                             let expr5_0 =
6924                                 constructor_x64_pcmpeq(ctx, pattern6_0, expr3_0, &expr4_0)?;
6925                             let expr6_0 = constructor_vector_all_ones(ctx, pattern6_0)?;
6926                             let expr7_0 = C::xmm_to_xmm_mem(ctx, expr6_0);
6927                             let expr8_0 = constructor_x64_pxor(ctx, expr5_0, &expr7_0)?;
6928                             let expr9_0 = constructor_output_xmm(ctx, expr8_0)?;
6929                             return Some(expr9_0);
6930                         }
6931                         &IntCC::UnsignedGreaterThanOrEqual => {
6932                             // Rule at src/isa/x64/lower.isle line 1502.
6933                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
6934                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?;
6935                             let expr2_0 =
6936                                 constructor_x64_pmaxu(ctx, pattern6_0, expr0_0, &expr1_0)?;
6937                             let expr3_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
6938                             let expr4_0 = C::xmm_to_xmm_mem(ctx, expr2_0);
6939                             let expr5_0 =
6940                                 constructor_x64_pcmpeq(ctx, pattern6_0, expr3_0, &expr4_0)?;
6941                             let expr6_0 = constructor_output_xmm(ctx, expr5_0)?;
6942                             return Some(expr6_0);
6943                         }
6944                         &IntCC::UnsignedLessThan => {
6945                             // Rule at src/isa/x64/lower.isle line 1485.
6946                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
6947                             let expr1_0 = constructor_put_in_xmm(ctx, pattern4_1)?;
6948                             let expr2_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
6949                             let expr3_0 =
6950                                 constructor_x64_pminu(ctx, pattern6_0, expr0_0, &expr2_0)?;
6951                             let expr4_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
6952                             let expr5_0 =
6953                                 constructor_x64_pcmpeq(ctx, pattern6_0, expr3_0, &expr4_0)?;
6954                             let expr6_0 = constructor_vector_all_ones(ctx, pattern6_0)?;
6955                             let expr7_0 = C::xmm_to_xmm_mem(ctx, expr6_0);
6956                             let expr8_0 = constructor_x64_pxor(ctx, expr5_0, &expr7_0)?;
6957                             let expr9_0 = constructor_output_xmm(ctx, expr8_0)?;
6958                             return Some(expr9_0);
6959                         }
6960                         &IntCC::UnsignedLessThanOrEqual => {
6961                             // Rule at src/isa/x64/lower.isle line 1505.
6962                             let expr0_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
6963                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern4_1)?;
6964                             let expr2_0 =
6965                                 constructor_x64_pminu(ctx, pattern6_0, expr0_0, &expr1_0)?;
6966                             let expr3_0 = constructor_put_in_xmm(ctx, pattern4_0)?;
6967                             let expr4_0 = C::xmm_to_xmm_mem(ctx, expr2_0);
6968                             let expr5_0 =
6969                                 constructor_x64_pcmpeq(ctx, pattern6_0, expr3_0, &expr4_0)?;
6970                             let expr6_0 = constructor_output_xmm(ctx, expr5_0)?;
6971                             return Some(expr6_0);
6972                         }
6973                         _ => {}
6974                     }
6975                 }
6976             }
6977         }
6978         &InstructionData::Unary {
6979             opcode: ref pattern2_0,
6980             arg: pattern2_1,
6981         } => {
6982             match pattern2_0 {
6983                 &Opcode::IsNull => {
6984                     let pattern4_0 = C::value_type(ctx, pattern2_1);
6985                     if pattern4_0 == R64 {
6986                         // Rule at src/isa/x64/lower.isle line 2097.
6987                         let expr0_0 = OperandSize::Size64;
6988                         let expr1_0: u32 = 0;
6989                         let expr2_0 = constructor_put_in_gpr(ctx, pattern2_1)?;
6990                         let expr3_0 = constructor_x64_cmp_imm(ctx, &expr0_0, expr1_0, expr2_0)?;
6991                         let expr4_0 = CC::Z;
6992                         let expr5_0 = constructor_x64_setcc(ctx, &expr4_0)?;
6993                         let expr6_0 = constructor_with_flags(ctx, &expr3_0, &expr5_0)?;
6994                         let expr7_0 = C::output(ctx, expr6_0);
6995                         return Some(expr7_0);
6996                     }
6997                 }
6998                 &Opcode::IsInvalid => {
6999                     let pattern4_0 = C::value_type(ctx, pattern2_1);
7000                     if pattern4_0 == R64 {
7001                         // Rule at src/isa/x64/lower.isle line 2105.
7002                         let expr0_0 = OperandSize::Size64;
7003                         let expr1_0: u32 = 4294967295;
7004                         let expr2_0 = constructor_put_in_gpr(ctx, pattern2_1)?;
7005                         let expr3_0 = constructor_x64_cmp_imm(ctx, &expr0_0, expr1_0, expr2_0)?;
7006                         let expr4_0 = CC::Z;
7007                         let expr5_0 = constructor_x64_setcc(ctx, &expr4_0)?;
7008                         let expr6_0 = constructor_with_flags(ctx, &expr3_0, &expr5_0)?;
7009                         let expr7_0 = C::output(ctx, expr6_0);
7010                         return Some(expr7_0);
7011                     }
7012                 }
7013                 _ => {}
7014             }
7015         }
7016         _ => {}
7017     }
7018     if let Some(pattern1_0) = C::first_result(ctx, pattern0_0) {
7019         let pattern2_0 = C::value_type(ctx, pattern1_0);
7020         if pattern2_0 == B128 {
7021             let pattern4_0 = C::inst_data(ctx, pattern0_0);
7022             match &pattern4_0 {
7023                 &InstructionData::UnaryBool {
7024                     opcode: ref pattern5_0,
7025                     imm: pattern5_1,
7026                 } => {
7027                     if let &Opcode::Bconst = pattern5_0 {
7028                         if pattern5_1 == true {
7029                             // Rule at src/isa/x64/lower.isle line 39.
7030                             let expr0_0: Type = B64;
7031                             let expr1_0: u64 = 1;
7032                             let expr2_0 = constructor_imm(ctx, expr0_0, expr1_0)?;
7033                             let expr3_0: Type = B64;
7034                             let expr4_0: u64 = 0;
7035                             let expr5_0 = constructor_imm(ctx, expr3_0, expr4_0)?;
7036                             let expr6_0 = C::value_regs(ctx, expr2_0, expr5_0);
7037                             let expr7_0 = C::output(ctx, expr6_0);
7038                             return Some(expr7_0);
7039                         }
7040                         if pattern5_1 == false {
7041                             // Rule at src/isa/x64/lower.isle line 34.
7042                             let expr0_0: Type = B64;
7043                             let expr1_0: u64 = 0;
7044                             let expr2_0 = constructor_imm(ctx, expr0_0, expr1_0)?;
7045                             let expr3_0: Type = B64;
7046                             let expr4_0: u64 = 0;
7047                             let expr5_0 = constructor_imm(ctx, expr3_0, expr4_0)?;
7048                             let expr6_0 = C::value_regs(ctx, expr2_0, expr5_0);
7049                             let expr7_0 = C::output(ctx, expr6_0);
7050                             return Some(expr7_0);
7051                         }
7052                     }
7053                 }
7054                 &InstructionData::Binary {
7055                     opcode: ref pattern5_0,
7056                     args: ref pattern5_1,
7057                 } => {
7058                     match pattern5_0 {
7059                         &Opcode::Band => {
7060                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7061                             // Rule at src/isa/x64/lower.isle line 344.
7062                             let expr0_0 = C::put_in_regs(ctx, pattern7_0);
7063                             let expr1_0: usize = 0;
7064                             let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?;
7065                             let expr3_0: usize = 1;
7066                             let expr4_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr3_0)?;
7067                             let expr5_0 = constructor_lo_gpr(ctx, pattern7_1)?;
7068                             let expr6_0: Type = I64;
7069                             let expr7_0 = C::gpr_to_gpr_mem_imm(ctx, expr5_0);
7070                             let expr8_0 = constructor_x64_and(ctx, expr6_0, expr2_0, &expr7_0)?;
7071                             let expr9_0 = constructor_value_gprs(ctx, expr8_0, expr4_0)?;
7072                             let expr10_0 = C::output(ctx, expr9_0);
7073                             return Some(expr10_0);
7074                         }
7075                         &Opcode::Bor => {
7076                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7077                             // Rule at src/isa/x64/lower.isle line 410.
7078                             let expr0_0 = C::put_in_regs(ctx, pattern7_0);
7079                             let expr1_0: usize = 0;
7080                             let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?;
7081                             let expr3_0: usize = 1;
7082                             let expr4_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr3_0)?;
7083                             let expr5_0 = constructor_lo_gpr(ctx, pattern7_1)?;
7084                             let expr6_0: Type = I64;
7085                             let expr7_0 = C::gpr_to_gpr_mem_imm(ctx, expr5_0);
7086                             let expr8_0 = constructor_x64_or(ctx, expr6_0, expr2_0, &expr7_0)?;
7087                             let expr9_0 = constructor_value_gprs(ctx, expr8_0, expr4_0)?;
7088                             let expr10_0 = C::output(ctx, expr9_0);
7089                             return Some(expr10_0);
7090                         }
7091                         &Opcode::Bxor => {
7092                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7093                             // Rule at src/isa/x64/lower.isle line 468.
7094                             let expr0_0 = C::put_in_regs(ctx, pattern7_0);
7095                             let expr1_0: usize = 0;
7096                             let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?;
7097                             let expr3_0: usize = 1;
7098                             let expr4_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr3_0)?;
7099                             let expr5_0 = constructor_lo_gpr(ctx, pattern7_1)?;
7100                             let expr6_0: Type = I64;
7101                             let expr7_0 = C::gpr_to_gpr_mem_imm(ctx, expr5_0);
7102                             let expr8_0 = constructor_x64_xor(ctx, expr6_0, expr2_0, &expr7_0)?;
7103                             let expr9_0 = constructor_value_gprs(ctx, expr8_0, expr4_0)?;
7104                             let expr10_0 = C::output(ctx, expr9_0);
7105                             return Some(expr10_0);
7106                         }
7107                         _ => {}
7108                     }
7109                 }
7110                 &InstructionData::Unary {
7111                     opcode: ref pattern5_0,
7112                     arg: pattern5_1,
7113                 } => {
7114                     if let &Opcode::Bnot = pattern5_0 {
7115                         // Rule at src/isa/x64/lower.isle line 1269.
7116                         let expr0_0 = constructor_i128_not(ctx, pattern5_1)?;
7117                         let expr1_0 = C::output(ctx, expr0_0);
7118                         return Some(expr1_0);
7119                     }
7120                 }
7121                 _ => {}
7122             }
7123         }
7124         if pattern2_0 == I8 {
7125             let pattern4_0 = C::inst_data(ctx, pattern0_0);
7126             if let &InstructionData::Unary {
7127                 opcode: ref pattern5_0,
7128                 arg: pattern5_1,
7129             } = &pattern4_0
7130             {
7131                 if let &Opcode::Bitrev = pattern5_0 {
7132                     // Rule at src/isa/x64/lower.isle line 2019.
7133                     let expr0_0: Type = I32;
7134                     let expr1_0 = constructor_put_in_gpr(ctx, pattern5_1)?;
7135                     let expr2_0 = constructor_do_bitrev8(ctx, expr0_0, expr1_0)?;
7136                     let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
7137                     return Some(expr3_0);
7138                 }
7139             }
7140         }
7141         if pattern2_0 == I16 {
7142             let pattern4_0 = C::inst_data(ctx, pattern0_0);
7143             if let &InstructionData::Unary {
7144                 opcode: ref pattern5_0,
7145                 arg: pattern5_1,
7146             } = &pattern4_0
7147             {
7148                 if let &Opcode::Bitrev = pattern5_0 {
7149                     // Rule at src/isa/x64/lower.isle line 2022.
7150                     let expr0_0: Type = I32;
7151                     let expr1_0 = constructor_put_in_gpr(ctx, pattern5_1)?;
7152                     let expr2_0 = constructor_do_bitrev16(ctx, expr0_0, expr1_0)?;
7153                     let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
7154                     return Some(expr3_0);
7155                 }
7156             }
7157         }
7158         if pattern2_0 == I32 {
7159             let pattern4_0 = C::inst_data(ctx, pattern0_0);
7160             if let &InstructionData::Unary {
7161                 opcode: ref pattern5_0,
7162                 arg: pattern5_1,
7163             } = &pattern4_0
7164             {
7165                 if let &Opcode::Bitrev = pattern5_0 {
7166                     // Rule at src/isa/x64/lower.isle line 2025.
7167                     let expr0_0: Type = I32;
7168                     let expr1_0 = constructor_put_in_gpr(ctx, pattern5_1)?;
7169                     let expr2_0 = constructor_do_bitrev32(ctx, expr0_0, expr1_0)?;
7170                     let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
7171                     return Some(expr3_0);
7172                 }
7173             }
7174         }
7175         if pattern2_0 == I64 {
7176             let pattern4_0 = C::inst_data(ctx, pattern0_0);
7177             if let &InstructionData::Unary {
7178                 opcode: ref pattern5_0,
7179                 arg: pattern5_1,
7180             } = &pattern4_0
7181             {
7182                 match pattern5_0 {
7183                     &Opcode::Bitrev => {
7184                         // Rule at src/isa/x64/lower.isle line 2028.
7185                         let expr0_0: Type = I64;
7186                         let expr1_0 = constructor_put_in_gpr(ctx, pattern5_1)?;
7187                         let expr2_0 = constructor_do_bitrev64(ctx, expr0_0, expr1_0)?;
7188                         let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
7189                         return Some(expr3_0);
7190                     }
7191                     &Opcode::Uextend => {
7192                         if let Some(pattern7_0) = C::def_inst(ctx, pattern5_1) {
7193                             if let Some(pattern8_0) = C::first_result(ctx, pattern7_0) {
7194                                 let pattern9_0 = C::value_type(ctx, pattern8_0);
7195                                 if pattern9_0 == I32 {
7196                                     let pattern11_0 = C::inst_data(ctx, pattern7_0);
7197                                     match &pattern11_0 {
7198                                         &InstructionData::Binary {
7199                                             opcode: ref pattern12_0,
7200                                             args: ref pattern12_1,
7201                                         } => {
7202                                             match pattern12_0 {
7203                                                 &Opcode::Iadd => {
7204                                                     let (pattern14_0, pattern14_1) =
7205                                                         C::unpack_value_array_2(ctx, pattern12_1);
7206                                                     // Rule at src/isa/x64/lower.isle line 2144.
7207                                                     let expr0_0 =
7208                                                         constructor_output_value(ctx, pattern5_1)?;
7209                                                     return Some(expr0_0);
7210                                                 }
7211                                                 &Opcode::Isub => {
7212                                                     let (pattern14_0, pattern14_1) =
7213                                                         C::unpack_value_array_2(ctx, pattern12_1);
7214                                                     // Rule at src/isa/x64/lower.isle line 2150.
7215                                                     let expr0_0 =
7216                                                         constructor_output_value(ctx, pattern5_1)?;
7217                                                     return Some(expr0_0);
7218                                                 }
7219                                                 &Opcode::Imul => {
7220                                                     let (pattern14_0, pattern14_1) =
7221                                                         C::unpack_value_array_2(ctx, pattern12_1);
7222                                                     // Rule at src/isa/x64/lower.isle line 2153.
7223                                                     let expr0_0 =
7224                                                         constructor_output_value(ctx, pattern5_1)?;
7225                                                     return Some(expr0_0);
7226                                                 }
7227                                                 &Opcode::IaddIfcout => {
7228                                                     let (pattern14_0, pattern14_1) =
7229                                                         C::unpack_value_array_2(ctx, pattern12_1);
7230                                                     // Rule at src/isa/x64/lower.isle line 2147.
7231                                                     let expr0_0 =
7232                                                         constructor_output_value(ctx, pattern5_1)?;
7233                                                     return Some(expr0_0);
7234                                                 }
7235                                                 &Opcode::Band => {
7236                                                     let (pattern14_0, pattern14_1) =
7237                                                         C::unpack_value_array_2(ctx, pattern12_1);
7238                                                     // Rule at src/isa/x64/lower.isle line 2156.
7239                                                     let expr0_0 =
7240                                                         constructor_output_value(ctx, pattern5_1)?;
7241                                                     return Some(expr0_0);
7242                                                 }
7243                                                 &Opcode::Bor => {
7244                                                     let (pattern14_0, pattern14_1) =
7245                                                         C::unpack_value_array_2(ctx, pattern12_1);
7246                                                     // Rule at src/isa/x64/lower.isle line 2159.
7247                                                     let expr0_0 =
7248                                                         constructor_output_value(ctx, pattern5_1)?;
7249                                                     return Some(expr0_0);
7250                                                 }
7251                                                 &Opcode::Bxor => {
7252                                                     let (pattern14_0, pattern14_1) =
7253                                                         C::unpack_value_array_2(ctx, pattern12_1);
7254                                                     // Rule at src/isa/x64/lower.isle line 2162.
7255                                                     let expr0_0 =
7256                                                         constructor_output_value(ctx, pattern5_1)?;
7257                                                     return Some(expr0_0);
7258                                                 }
7259                                                 &Opcode::Ishl => {
7260                                                     let (pattern14_0, pattern14_1) =
7261                                                         C::unpack_value_array_2(ctx, pattern12_1);
7262                                                     // Rule at src/isa/x64/lower.isle line 2165.
7263                                                     let expr0_0 =
7264                                                         constructor_output_value(ctx, pattern5_1)?;
7265                                                     return Some(expr0_0);
7266                                                 }
7267                                                 &Opcode::Ushr => {
7268                                                     let (pattern14_0, pattern14_1) =
7269                                                         C::unpack_value_array_2(ctx, pattern12_1);
7270                                                     // Rule at src/isa/x64/lower.isle line 2168.
7271                                                     let expr0_0 =
7272                                                         constructor_output_value(ctx, pattern5_1)?;
7273                                                     return Some(expr0_0);
7274                                                 }
7275                                                 _ => {}
7276                                             }
7277                                         }
7278                                         &InstructionData::Load {
7279                                             opcode: ref pattern12_0,
7280                                             arg: pattern12_1,
7281                                             flags: pattern12_2,
7282                                             offset: pattern12_3,
7283                                         } => {
7284                                             if let &Opcode::Uload32 = pattern12_0 {
7285                                                 // Rule at src/isa/x64/lower.isle line 2171.
7286                                                 let expr0_0 =
7287                                                     constructor_output_value(ctx, pattern5_1)?;
7288                                                 return Some(expr0_0);
7289                                             }
7290                                         }
7291                                         _ => {}
7292                                     }
7293                                 }
7294                             }
7295                         }
7296                         let pattern7_0 = C::value_type(ctx, pattern5_1);
7297                         if let Some(pattern8_0) = C::fits_in_32(ctx, pattern7_0) {
7298                             // Rule at src/isa/x64/lower.isle line 2126.
7299                             let expr0_0: Type = I64;
7300                             let expr1_0 = ExtendKind::Zero;
7301                             let expr2_0 =
7302                                 constructor_extend_to_gpr(ctx, pattern5_1, expr0_0, &expr1_0)?;
7303                             let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
7304                             return Some(expr3_0);
7305                         }
7306                     }
7307                     _ => {}
7308                 }
7309             }
7310         }
7311         if pattern2_0 == I128 {
7312             let pattern4_0 = C::inst_data(ctx, pattern0_0);
7313             match &pattern4_0 {
7314                 &InstructionData::UnaryImm {
7315                     opcode: ref pattern5_0,
7316                     imm: pattern5_1,
7317                 } => {
7318                     if let &Opcode::Iconst = pattern5_0 {
7319                         let pattern7_0 = C::u64_from_imm64(ctx, pattern5_1);
7320                         // Rule at src/isa/x64/lower.isle line 15.
7321                         let expr0_0: Type = I64;
7322                         let expr1_0 = constructor_imm(ctx, expr0_0, pattern7_0)?;
7323                         let expr2_0: Type = I64;
7324                         let expr3_0: u64 = 0;
7325                         let expr4_0 = constructor_imm(ctx, expr2_0, expr3_0)?;
7326                         let expr5_0 = C::value_regs(ctx, expr1_0, expr4_0);
7327                         let expr6_0 = C::output(ctx, expr5_0);
7328                         return Some(expr6_0);
7329                     }
7330                 }
7331                 &InstructionData::Binary {
7332                     opcode: ref pattern5_0,
7333                     args: ref pattern5_1,
7334                 } => {
7335                     match pattern5_0 {
7336                         &Opcode::Iadd => {
7337                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7338                             // Rule at src/isa/x64/lower.isle line 111.
7339                             let expr0_0 = C::put_in_regs(ctx, pattern7_0);
7340                             let expr1_0: usize = 0;
7341                             let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?;
7342                             let expr3_0: usize = 1;
7343                             let expr4_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr3_0)?;
7344                             let expr5_0 = C::put_in_regs(ctx, pattern7_1);
7345                             let expr6_0: usize = 0;
7346                             let expr7_0 = constructor_value_regs_get_gpr(ctx, expr5_0, expr6_0)?;
7347                             let expr8_0: usize = 1;
7348                             let expr9_0 = constructor_value_regs_get_gpr(ctx, expr5_0, expr8_0)?;
7349                             let expr10_0: Type = I64;
7350                             let expr11_0 = C::gpr_to_gpr_mem_imm(ctx, expr7_0);
7351                             let expr12_0 = constructor_x64_add_with_flags_paired(
7352                                 ctx, expr10_0, expr2_0, &expr11_0,
7353                             )?;
7354                             let expr13_0: Type = I64;
7355                             let expr14_0 = C::gpr_to_gpr_mem_imm(ctx, expr9_0);
7356                             let expr15_0 =
7357                                 constructor_x64_adc_paired(ctx, expr13_0, expr4_0, &expr14_0)?;
7358                             let expr16_0 = constructor_with_flags(ctx, &expr12_0, &expr15_0)?;
7359                             let expr17_0 = C::output(ctx, expr16_0);
7360                             return Some(expr17_0);
7361                         }
7362                         &Opcode::Isub => {
7363                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7364                             // Rule at src/isa/x64/lower.isle line 257.
7365                             let expr0_0 = C::put_in_regs(ctx, pattern7_0);
7366                             let expr1_0: usize = 0;
7367                             let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?;
7368                             let expr3_0: usize = 1;
7369                             let expr4_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr3_0)?;
7370                             let expr5_0 = C::put_in_regs(ctx, pattern7_1);
7371                             let expr6_0: usize = 0;
7372                             let expr7_0 = constructor_value_regs_get_gpr(ctx, expr5_0, expr6_0)?;
7373                             let expr8_0: usize = 1;
7374                             let expr9_0 = constructor_value_regs_get_gpr(ctx, expr5_0, expr8_0)?;
7375                             let expr10_0: Type = I64;
7376                             let expr11_0 = C::gpr_to_gpr_mem_imm(ctx, expr7_0);
7377                             let expr12_0 = constructor_x64_sub_with_flags_paired(
7378                                 ctx, expr10_0, expr2_0, &expr11_0,
7379                             )?;
7380                             let expr13_0: Type = I64;
7381                             let expr14_0 = C::gpr_to_gpr_mem_imm(ctx, expr9_0);
7382                             let expr15_0 =
7383                                 constructor_x64_sbb_paired(ctx, expr13_0, expr4_0, &expr14_0)?;
7384                             let expr16_0 = constructor_with_flags(ctx, &expr12_0, &expr15_0)?;
7385                             let expr17_0 = C::output(ctx, expr16_0);
7386                             return Some(expr17_0);
7387                         }
7388                         &Opcode::Imul => {
7389                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7390                             // Rule at src/isa/x64/lower.isle line 957.
7391                             let expr0_0 = C::put_in_regs(ctx, pattern7_0);
7392                             let expr1_0: usize = 0;
7393                             let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?;
7394                             let expr3_0: usize = 1;
7395                             let expr4_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr3_0)?;
7396                             let expr5_0 = C::put_in_regs(ctx, pattern7_1);
7397                             let expr6_0: usize = 0;
7398                             let expr7_0 = constructor_value_regs_get_gpr(ctx, expr5_0, expr6_0)?;
7399                             let expr8_0: usize = 1;
7400                             let expr9_0 = constructor_value_regs_get_gpr(ctx, expr5_0, expr8_0)?;
7401                             let expr10_0: Type = I64;
7402                             let expr11_0 = C::gpr_to_gpr_mem_imm(ctx, expr9_0);
7403                             let expr12_0 = constructor_x64_mul(ctx, expr10_0, expr2_0, &expr11_0)?;
7404                             let expr13_0: Type = I64;
7405                             let expr14_0 = C::gpr_to_gpr_mem_imm(ctx, expr7_0);
7406                             let expr15_0 = constructor_x64_mul(ctx, expr13_0, expr4_0, &expr14_0)?;
7407                             let expr16_0: Type = I64;
7408                             let expr17_0 = C::gpr_to_gpr_mem_imm(ctx, expr15_0);
7409                             let expr18_0 = constructor_x64_add(ctx, expr16_0, expr12_0, &expr17_0)?;
7410                             let expr19_0: Type = I64;
7411                             let expr20_0 = C::gpr_to_gpr_mem(ctx, expr7_0);
7412                             let expr21_0 = constructor_mulhi_u(ctx, expr19_0, expr2_0, &expr20_0)?;
7413                             let expr22_0: usize = 0;
7414                             let expr23_0 = constructor_value_regs_get_gpr(ctx, expr21_0, expr22_0)?;
7415                             let expr24_0: usize = 1;
7416                             let expr25_0 = constructor_value_regs_get_gpr(ctx, expr21_0, expr24_0)?;
7417                             let expr26_0: Type = I64;
7418                             let expr27_0 = C::gpr_to_gpr_mem_imm(ctx, expr25_0);
7419                             let expr28_0 = constructor_x64_add(ctx, expr26_0, expr18_0, &expr27_0)?;
7420                             let expr29_0 = constructor_value_gprs(ctx, expr23_0, expr28_0)?;
7421                             let expr30_0 = C::output(ctx, expr29_0);
7422                             return Some(expr30_0);
7423                         }
7424                         &Opcode::Band => {
7425                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7426                             // Rule at src/isa/x64/lower.isle line 334.
7427                             let expr0_0 = C::put_in_regs(ctx, pattern7_0);
7428                             let expr1_0: usize = 0;
7429                             let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?;
7430                             let expr3_0: usize = 1;
7431                             let expr4_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr3_0)?;
7432                             let expr5_0 = C::put_in_regs(ctx, pattern7_1);
7433                             let expr6_0: usize = 0;
7434                             let expr7_0 = constructor_value_regs_get_gpr(ctx, expr5_0, expr6_0)?;
7435                             let expr8_0: usize = 1;
7436                             let expr9_0 = constructor_value_regs_get_gpr(ctx, expr5_0, expr8_0)?;
7437                             let expr10_0: Type = I64;
7438                             let expr11_0 = C::gpr_to_gpr_mem_imm(ctx, expr7_0);
7439                             let expr12_0 = constructor_x64_and(ctx, expr10_0, expr2_0, &expr11_0)?;
7440                             let expr13_0: Type = I64;
7441                             let expr14_0 = C::gpr_to_gpr_mem_imm(ctx, expr9_0);
7442                             let expr15_0 = constructor_x64_and(ctx, expr13_0, expr4_0, &expr14_0)?;
7443                             let expr16_0 = constructor_value_gprs(ctx, expr12_0, expr15_0)?;
7444                             let expr17_0 = C::output(ctx, expr16_0);
7445                             return Some(expr17_0);
7446                         }
7447                         &Opcode::Bor => {
7448                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7449                             // Rule at src/isa/x64/lower.isle line 407.
7450                             let expr0_0 = C::put_in_regs(ctx, pattern7_0);
7451                             let expr1_0 = C::put_in_regs(ctx, pattern7_1);
7452                             let expr2_0 = constructor_or_i128(ctx, expr0_0, expr1_0)?;
7453                             let expr3_0 = C::output(ctx, expr2_0);
7454                             return Some(expr3_0);
7455                         }
7456                         &Opcode::Bxor => {
7457                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7458                             // Rule at src/isa/x64/lower.isle line 458.
7459                             let expr0_0 = C::put_in_regs(ctx, pattern7_0);
7460                             let expr1_0: usize = 0;
7461                             let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?;
7462                             let expr3_0: usize = 1;
7463                             let expr4_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr3_0)?;
7464                             let expr5_0 = C::put_in_regs(ctx, pattern7_1);
7465                             let expr6_0: usize = 0;
7466                             let expr7_0 = constructor_value_regs_get_gpr(ctx, expr5_0, expr6_0)?;
7467                             let expr8_0: usize = 1;
7468                             let expr9_0 = constructor_value_regs_get_gpr(ctx, expr5_0, expr8_0)?;
7469                             let expr10_0: Type = I64;
7470                             let expr11_0 = C::gpr_to_gpr_mem_imm(ctx, expr7_0);
7471                             let expr12_0 = constructor_x64_xor(ctx, expr10_0, expr2_0, &expr11_0)?;
7472                             let expr13_0: Type = I64;
7473                             let expr14_0 = C::gpr_to_gpr_mem_imm(ctx, expr9_0);
7474                             let expr15_0 = constructor_x64_xor(ctx, expr13_0, expr4_0, &expr14_0)?;
7475                             let expr16_0 = constructor_value_gprs(ctx, expr12_0, expr15_0)?;
7476                             let expr17_0 = C::output(ctx, expr16_0);
7477                             return Some(expr17_0);
7478                         }
7479                         &Opcode::Rotl => {
7480                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7481                             // Rule at src/isa/x64/lower.isle line 830.
7482                             let expr0_0 = C::put_in_regs(ctx, pattern7_0);
7483                             let expr1_0 = constructor_lo_gpr(ctx, pattern7_1)?;
7484                             let expr2_0 = constructor_shl_i128(ctx, expr0_0, expr1_0)?;
7485                             let expr3_0: Type = I64;
7486                             let expr4_0: Type = I64;
7487                             let expr5_0: u64 = 128;
7488                             let expr6_0 = constructor_imm(ctx, expr4_0, expr5_0)?;
7489                             let expr7_0 = C::gpr_new(ctx, expr6_0);
7490                             let expr8_0 = C::gpr_to_gpr_mem_imm(ctx, expr1_0);
7491                             let expr9_0 = constructor_x64_sub(ctx, expr3_0, expr7_0, &expr8_0)?;
7492                             let expr10_0 = constructor_shr_i128(ctx, expr0_0, expr9_0)?;
7493                             let expr11_0 = constructor_or_i128(ctx, expr2_0, expr10_0)?;
7494                             let expr12_0 = C::output(ctx, expr11_0);
7495                             return Some(expr12_0);
7496                         }
7497                         &Opcode::Rotr => {
7498                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7499                             // Rule at src/isa/x64/lower.isle line 870.
7500                             let expr0_0 = C::put_in_regs(ctx, pattern7_0);
7501                             let expr1_0 = constructor_lo_gpr(ctx, pattern7_1)?;
7502                             let expr2_0 = constructor_shr_i128(ctx, expr0_0, expr1_0)?;
7503                             let expr3_0: Type = I64;
7504                             let expr4_0: Type = I64;
7505                             let expr5_0: u64 = 128;
7506                             let expr6_0 = constructor_imm(ctx, expr4_0, expr5_0)?;
7507                             let expr7_0 = C::gpr_new(ctx, expr6_0);
7508                             let expr8_0 = C::gpr_to_gpr_mem_imm(ctx, expr1_0);
7509                             let expr9_0 = constructor_x64_sub(ctx, expr3_0, expr7_0, &expr8_0)?;
7510                             let expr10_0 = constructor_shl_i128(ctx, expr0_0, expr9_0)?;
7511                             let expr11_0 = constructor_or_i128(ctx, expr2_0, expr10_0)?;
7512                             let expr12_0 = C::output(ctx, expr11_0);
7513                             return Some(expr12_0);
7514                         }
7515                         &Opcode::Ishl => {
7516                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7517                             // Rule at src/isa/x64/lower.isle line 522.
7518                             let expr0_0 = constructor_lo_gpr(ctx, pattern7_1)?;
7519                             let expr1_0 = C::put_in_regs(ctx, pattern7_0);
7520                             let expr2_0 = constructor_shl_i128(ctx, expr1_0, expr0_0)?;
7521                             let expr3_0 = C::output(ctx, expr2_0);
7522                             return Some(expr3_0);
7523                         }
7524                         &Opcode::Ushr => {
7525                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7526                             // Rule at src/isa/x64/lower.isle line 623.
7527                             let expr0_0 = constructor_lo_gpr(ctx, pattern7_1)?;
7528                             let expr1_0 = C::put_in_regs(ctx, pattern7_0);
7529                             let expr2_0 = constructor_shr_i128(ctx, expr1_0, expr0_0)?;
7530                             let expr3_0 = C::output(ctx, expr2_0);
7531                             return Some(expr3_0);
7532                         }
7533                         &Opcode::Sshr => {
7534                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7535                             // Rule at src/isa/x64/lower.isle line 728.
7536                             let expr0_0 = constructor_lo_gpr(ctx, pattern7_1)?;
7537                             let expr1_0 = C::put_in_regs(ctx, pattern7_0);
7538                             let expr2_0 = constructor_sar_i128(ctx, expr1_0, expr0_0)?;
7539                             let expr3_0 = C::output(ctx, expr2_0);
7540                             return Some(expr3_0);
7541                         }
7542                         _ => {}
7543                     }
7544                 }
7545                 &InstructionData::Unary {
7546                     opcode: ref pattern5_0,
7547                     arg: pattern5_1,
7548                 } => {
7549                     match pattern5_0 {
7550                         &Opcode::Bnot => {
7551                             // Rule at src/isa/x64/lower.isle line 1266.
7552                             let expr0_0 = constructor_i128_not(ctx, pattern5_1)?;
7553                             let expr1_0 = C::output(ctx, expr0_0);
7554                             return Some(expr1_0);
7555                         }
7556                         &Opcode::Bitrev => {
7557                             // Rule at src/isa/x64/lower.isle line 2031.
7558                             let expr0_0: Type = I64;
7559                             let expr1_0 = C::put_in_regs(ctx, pattern5_1);
7560                             let expr2_0: usize = 1;
7561                             let expr3_0 = constructor_value_regs_get_gpr(ctx, expr1_0, expr2_0)?;
7562                             let expr4_0 = constructor_do_bitrev64(ctx, expr0_0, expr3_0)?;
7563                             let expr5_0 = C::gpr_to_reg(ctx, expr4_0);
7564                             let expr6_0: Type = I64;
7565                             let expr7_0 = C::put_in_regs(ctx, pattern5_1);
7566                             let expr8_0: usize = 0;
7567                             let expr9_0 = constructor_value_regs_get_gpr(ctx, expr7_0, expr8_0)?;
7568                             let expr10_0 = constructor_do_bitrev64(ctx, expr6_0, expr9_0)?;
7569                             let expr11_0 = C::gpr_to_reg(ctx, expr10_0);
7570                             let expr12_0 = C::value_regs(ctx, expr5_0, expr11_0);
7571                             let expr13_0 = C::output(ctx, expr12_0);
7572                             return Some(expr13_0);
7573                         }
7574                         &Opcode::Clz => {
7575                             // Rule at src/isa/x64/lower.isle line 1801.
7576                             let expr0_0: Type = I64;
7577                             let expr1_0: Type = I64;
7578                             let expr2_0 = C::put_in_regs(ctx, pattern5_1);
7579                             let expr3_0: usize = 1;
7580                             let expr4_0 = constructor_value_regs_get_gpr(ctx, expr2_0, expr3_0)?;
7581                             let expr5_0 = constructor_do_clz(ctx, expr0_0, expr1_0, expr4_0)?;
7582                             let expr6_0: Type = I64;
7583                             let expr7_0: Type = I64;
7584                             let expr8_0: Type = I64;
7585                             let expr9_0 = C::put_in_regs(ctx, pattern5_1);
7586                             let expr10_0: usize = 0;
7587                             let expr11_0 = constructor_value_regs_get_gpr(ctx, expr9_0, expr10_0)?;
7588                             let expr12_0 = constructor_do_clz(ctx, expr7_0, expr8_0, expr11_0)?;
7589                             let expr13_0: u32 = 64;
7590                             let expr14_0 = RegMemImm::Imm { simm32: expr13_0 };
7591                             let expr15_0 = C::gpr_mem_imm_new(ctx, &expr14_0);
7592                             let expr16_0 = constructor_x64_add(ctx, expr6_0, expr12_0, &expr15_0)?;
7593                             let expr17_0 = OperandSize::Size64;
7594                             let expr18_0: u32 = 64;
7595                             let expr19_0 =
7596                                 constructor_x64_cmp_imm(ctx, &expr17_0, expr18_0, expr5_0)?;
7597                             let expr20_0: Type = I64;
7598                             let expr21_0 = CC::NZ;
7599                             let expr22_0 = C::gpr_to_gpr_mem(ctx, expr5_0);
7600                             let expr23_0 =
7601                                 constructor_cmove(ctx, expr20_0, &expr21_0, &expr22_0, expr16_0)?;
7602                             let expr24_0 = constructor_with_flags_reg(ctx, &expr19_0, &expr23_0)?;
7603                             let expr25_0 = C::gpr_new(ctx, expr24_0);
7604                             let expr26_0 = C::gpr_to_reg(ctx, expr25_0);
7605                             let expr27_0: Type = I64;
7606                             let expr28_0: u64 = 0;
7607                             let expr29_0 = constructor_imm(ctx, expr27_0, expr28_0)?;
7608                             let expr30_0 = C::value_regs(ctx, expr26_0, expr29_0);
7609                             let expr31_0 = C::output(ctx, expr30_0);
7610                             return Some(expr31_0);
7611                         }
7612                         &Opcode::Ctz => {
7613                             // Rule at src/isa/x64/lower.isle line 1843.
7614                             let expr0_0: Type = I64;
7615                             let expr1_0: Type = I64;
7616                             let expr2_0 = C::put_in_regs(ctx, pattern5_1);
7617                             let expr3_0: usize = 0;
7618                             let expr4_0 = constructor_value_regs_get_gpr(ctx, expr2_0, expr3_0)?;
7619                             let expr5_0 = constructor_do_ctz(ctx, expr0_0, expr1_0, expr4_0)?;
7620                             let expr6_0: Type = I64;
7621                             let expr7_0: Type = I64;
7622                             let expr8_0: Type = I64;
7623                             let expr9_0 = C::put_in_regs(ctx, pattern5_1);
7624                             let expr10_0: usize = 1;
7625                             let expr11_0 = constructor_value_regs_get_gpr(ctx, expr9_0, expr10_0)?;
7626                             let expr12_0 = constructor_do_ctz(ctx, expr7_0, expr8_0, expr11_0)?;
7627                             let expr13_0: u32 = 64;
7628                             let expr14_0 = RegMemImm::Imm { simm32: expr13_0 };
7629                             let expr15_0 = C::gpr_mem_imm_new(ctx, &expr14_0);
7630                             let expr16_0 = constructor_x64_add(ctx, expr6_0, expr12_0, &expr15_0)?;
7631                             let expr17_0 = OperandSize::Size64;
7632                             let expr18_0: u32 = 64;
7633                             let expr19_0 =
7634                                 constructor_x64_cmp_imm(ctx, &expr17_0, expr18_0, expr5_0)?;
7635                             let expr20_0: Type = I64;
7636                             let expr21_0 = CC::Z;
7637                             let expr22_0 = C::gpr_to_gpr_mem(ctx, expr16_0);
7638                             let expr23_0 =
7639                                 constructor_cmove(ctx, expr20_0, &expr21_0, &expr22_0, expr5_0)?;
7640                             let expr24_0 = constructor_with_flags_reg(ctx, &expr19_0, &expr23_0)?;
7641                             let expr25_0 = C::gpr_new(ctx, expr24_0);
7642                             let expr26_0 = C::gpr_to_reg(ctx, expr25_0);
7643                             let expr27_0: Type = I64;
7644                             let expr28_0: u64 = 0;
7645                             let expr29_0 = constructor_imm(ctx, expr27_0, expr28_0)?;
7646                             let expr30_0 = C::value_regs(ctx, expr26_0, expr29_0);
7647                             let expr31_0 = C::output(ctx, expr30_0);
7648                             return Some(expr31_0);
7649                         }
7650                         &Opcode::Popcnt => {
7651                             // Rule at src/isa/x64/lower.isle line 1895.
7652                             let expr0_0: Type = I64;
7653                             let expr1_0 = C::put_in_regs(ctx, pattern5_1);
7654                             let expr2_0: usize = 0;
7655                             let expr3_0 = constructor_value_regs_get_gpr(ctx, expr1_0, expr2_0)?;
7656                             let expr4_0 = constructor_do_popcnt(ctx, expr0_0, expr3_0)?;
7657                             let expr5_0: Type = I64;
7658                             let expr6_0 = C::put_in_regs(ctx, pattern5_1);
7659                             let expr7_0: usize = 1;
7660                             let expr8_0 = constructor_value_regs_get_gpr(ctx, expr6_0, expr7_0)?;
7661                             let expr9_0 = constructor_do_popcnt(ctx, expr5_0, expr8_0)?;
7662                             let expr10_0: Type = I64;
7663                             let expr11_0 = C::gpr_to_gpr_mem_imm(ctx, expr9_0);
7664                             let expr12_0 = constructor_x64_add(ctx, expr10_0, expr4_0, &expr11_0)?;
7665                             let expr13_0 = C::gpr_to_reg(ctx, expr12_0);
7666                             let expr14_0: Type = I64;
7667                             let expr15_0: u64 = 0;
7668                             let expr16_0 = constructor_imm(ctx, expr14_0, expr15_0)?;
7669                             let expr17_0 = C::value_regs(ctx, expr13_0, expr16_0);
7670                             let expr18_0 = C::output(ctx, expr17_0);
7671                             return Some(expr18_0);
7672                         }
7673                         &Opcode::Bint => {
7674                             // Rule at src/isa/x64/lower.isle line 2246.
7675                             let expr0_0: Type = I64;
7676                             let expr1_0 = constructor_put_in_gpr(ctx, pattern5_1)?;
7677                             let expr2_0: u32 = 1;
7678                             let expr3_0 = RegMemImm::Imm { simm32: expr2_0 };
7679                             let expr4_0 = C::gpr_mem_imm_new(ctx, &expr3_0);
7680                             let expr5_0 = constructor_x64_and(ctx, expr0_0, expr1_0, &expr4_0)?;
7681                             let expr6_0 = C::gpr_to_reg(ctx, expr5_0);
7682                             let expr7_0: Type = I64;
7683                             let expr8_0: u64 = 0;
7684                             let expr9_0 = constructor_imm(ctx, expr7_0, expr8_0)?;
7685                             let expr10_0 = C::value_regs(ctx, expr6_0, expr9_0);
7686                             let expr11_0 = C::output(ctx, expr10_0);
7687                             return Some(expr11_0);
7688                         }
7689                         &Opcode::Uextend => {
7690                             let pattern7_0 = C::value_type(ctx, pattern5_1);
7691                             if pattern7_0 == I64 {
7692                                 // Rule at src/isa/x64/lower.isle line 2118.
7693                                 let expr0_0 = C::put_in_reg(ctx, pattern5_1);
7694                                 let expr1_0: Type = I64;
7695                                 let expr2_0: u64 = 0;
7696                                 let expr3_0 = constructor_imm(ctx, expr1_0, expr2_0)?;
7697                                 let expr4_0 = C::value_regs(ctx, expr0_0, expr3_0);
7698                                 let expr5_0 = C::output(ctx, expr4_0);
7699                                 return Some(expr5_0);
7700                             }
7701                             if let Some(pattern8_0) = C::fits_in_32(ctx, pattern7_0) {
7702                                 // Rule at src/isa/x64/lower.isle line 2122.
7703                                 let expr0_0: Type = I64;
7704                                 let expr1_0 = ExtendKind::Zero;
7705                                 let expr2_0 =
7706                                     constructor_extend_to_gpr(ctx, pattern5_1, expr0_0, &expr1_0)?;
7707                                 let expr3_0 = C::gpr_to_reg(ctx, expr2_0);
7708                                 let expr4_0: Type = I64;
7709                                 let expr5_0: u64 = 0;
7710                                 let expr6_0 = constructor_imm(ctx, expr4_0, expr5_0)?;
7711                                 let expr7_0 = C::value_regs(ctx, expr3_0, expr6_0);
7712                                 let expr8_0 = C::output(ctx, expr7_0);
7713                                 return Some(expr8_0);
7714                             }
7715                         }
7716                         _ => {}
7717                     }
7718                 }
7719                 &InstructionData::BinaryImm64 {
7720                     opcode: ref pattern5_0,
7721                     arg: pattern5_1,
7722                     imm: pattern5_2,
7723                 } => {
7724                     if let &Opcode::IaddImm = pattern5_0 {
7725                         let pattern7_0 = C::u64_from_imm64(ctx, pattern5_2);
7726                         // Rule at src/isa/x64/lower.isle line 210.
7727                         let expr0_0 = C::put_in_regs(ctx, pattern5_1);
7728                         let expr1_0: usize = 0;
7729                         let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?;
7730                         let expr3_0: usize = 1;
7731                         let expr4_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr3_0)?;
7732                         let expr5_0: Type = I64;
7733                         let expr6_0 = constructor_imm(ctx, expr5_0, pattern7_0)?;
7734                         let expr7_0 = C::gpr_new(ctx, expr6_0);
7735                         let expr8_0: Type = I64;
7736                         let expr9_0 = C::gpr_to_gpr_mem_imm(ctx, expr7_0);
7737                         let expr10_0 =
7738                             constructor_x64_add_with_flags_paired(ctx, expr8_0, expr2_0, &expr9_0)?;
7739                         let expr11_0: Type = I64;
7740                         let expr12_0: u32 = 0;
7741                         let expr13_0 = RegMemImm::Imm { simm32: expr12_0 };
7742                         let expr14_0 = C::gpr_mem_imm_new(ctx, &expr13_0);
7743                         let expr15_0 =
7744                             constructor_x64_adc_paired(ctx, expr11_0, expr4_0, &expr14_0)?;
7745                         let expr16_0 = constructor_with_flags(ctx, &expr10_0, &expr15_0)?;
7746                         let expr17_0 = C::output(ctx, expr16_0);
7747                         return Some(expr17_0);
7748                     }
7749                 }
7750                 _ => {}
7751             }
7752         }
7753         if pattern2_0 == F32 {
7754             let pattern4_0 = C::inst_data(ctx, pattern0_0);
7755             match &pattern4_0 {
7756                 &InstructionData::Binary {
7757                     opcode: ref pattern5_0,
7758                     args: ref pattern5_1,
7759                 } => {
7760                     match pattern5_0 {
7761                         &Opcode::Fadd => {
7762                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7763                             // Rule at src/isa/x64/lower.isle line 2269.
7764                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7765                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
7766                             let expr2_0 = constructor_x64_addss(ctx, expr0_0, &expr1_0)?;
7767                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7768                             return Some(expr3_0);
7769                         }
7770                         &Opcode::Fsub => {
7771                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7772                             // Rule at src/isa/x64/lower.isle line 2280.
7773                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7774                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
7775                             let expr2_0 = constructor_x64_subss(ctx, expr0_0, &expr1_0)?;
7776                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7777                             return Some(expr3_0);
7778                         }
7779                         &Opcode::Fmul => {
7780                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7781                             // Rule at src/isa/x64/lower.isle line 2291.
7782                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7783                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
7784                             let expr2_0 = constructor_x64_mulss(ctx, expr0_0, &expr1_0)?;
7785                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7786                             return Some(expr3_0);
7787                         }
7788                         &Opcode::Fdiv => {
7789                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7790                             // Rule at src/isa/x64/lower.isle line 2302.
7791                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7792                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
7793                             let expr2_0 = constructor_x64_divss(ctx, expr0_0, &expr1_0)?;
7794                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7795                             return Some(expr3_0);
7796                         }
7797                         &Opcode::Fmin => {
7798                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7799                             // Rule at src/isa/x64/lower.isle line 2323.
7800                             let expr0_0: Type = F32;
7801                             let expr1_0: bool = true;
7802                             let expr2_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7803                             let expr3_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
7804                             let expr4_0 = constructor_xmm_min_max_seq(
7805                                 ctx, expr0_0, expr1_0, expr2_0, expr3_0,
7806                             )?;
7807                             let expr5_0 = constructor_output_xmm(ctx, expr4_0)?;
7808                             return Some(expr5_0);
7809                         }
7810                         &Opcode::FminPseudo => {
7811                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7812                             // Rule at src/isa/x64/lower.isle line 2492.
7813                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
7814                             let expr1_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7815                             let expr2_0 = constructor_x64_minss(ctx, expr0_0, expr1_0)?;
7816                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7817                             return Some(expr3_0);
7818                         }
7819                         &Opcode::Fmax => {
7820                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7821                             // Rule at src/isa/x64/lower.isle line 2395.
7822                             let expr0_0: Type = F32;
7823                             let expr1_0: bool = false;
7824                             let expr2_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7825                             let expr3_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
7826                             let expr4_0 = constructor_xmm_min_max_seq(
7827                                 ctx, expr0_0, expr1_0, expr2_0, expr3_0,
7828                             )?;
7829                             let expr5_0 = constructor_output_xmm(ctx, expr4_0)?;
7830                             return Some(expr5_0);
7831                         }
7832                         &Opcode::FmaxPseudo => {
7833                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7834                             // Rule at src/isa/x64/lower.isle line 2503.
7835                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
7836                             let expr1_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7837                             let expr2_0 = constructor_x64_maxss(ctx, expr0_0, expr1_0)?;
7838                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7839                             return Some(expr3_0);
7840                         }
7841                         _ => {}
7842                     }
7843                 }
7844                 &InstructionData::Unary {
7845                     opcode: ref pattern5_0,
7846                     arg: pattern5_1,
7847                 } => {
7848                     if let &Opcode::Sqrt = pattern5_0 {
7849                         // Rule at src/isa/x64/lower.isle line 2312.
7850                         let expr0_0 = constructor_put_in_xmm(ctx, pattern5_1)?;
7851                         let expr1_0 = constructor_x64_sqrtss(ctx, expr0_0)?;
7852                         let expr2_0 = constructor_output_xmm(ctx, expr1_0)?;
7853                         return Some(expr2_0);
7854                     }
7855                 }
7856                 &InstructionData::Load {
7857                     opcode: ref pattern5_0,
7858                     arg: pattern5_1,
7859                     flags: pattern5_2,
7860                     offset: pattern5_3,
7861                 } => {
7862                     if let &Opcode::Load = pattern5_0 {
7863                         // Rule at src/isa/x64/lower.isle line 2546.
7864                         let expr0_0 =
7865                             constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
7866                         let expr1_0 = constructor_amode_to_xmm_mem(ctx, &expr0_0)?;
7867                         let expr2_0 = constructor_x64_movss_load(ctx, &expr1_0)?;
7868                         let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7869                         return Some(expr3_0);
7870                     }
7871                 }
7872                 _ => {}
7873             }
7874         }
7875         if pattern2_0 == F64 {
7876             let pattern4_0 = C::inst_data(ctx, pattern0_0);
7877             match &pattern4_0 {
7878                 &InstructionData::Binary {
7879                     opcode: ref pattern5_0,
7880                     args: ref pattern5_1,
7881                 } => {
7882                     match pattern5_0 {
7883                         &Opcode::Fadd => {
7884                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7885                             // Rule at src/isa/x64/lower.isle line 2271.
7886                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7887                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
7888                             let expr2_0 = constructor_x64_addsd(ctx, expr0_0, &expr1_0)?;
7889                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7890                             return Some(expr3_0);
7891                         }
7892                         &Opcode::Fsub => {
7893                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7894                             // Rule at src/isa/x64/lower.isle line 2282.
7895                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7896                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
7897                             let expr2_0 = constructor_x64_subsd(ctx, expr0_0, &expr1_0)?;
7898                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7899                             return Some(expr3_0);
7900                         }
7901                         &Opcode::Fmul => {
7902                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7903                             // Rule at src/isa/x64/lower.isle line 2293.
7904                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7905                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
7906                             let expr2_0 = constructor_x64_mulsd(ctx, expr0_0, &expr1_0)?;
7907                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7908                             return Some(expr3_0);
7909                         }
7910                         &Opcode::Fdiv => {
7911                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7912                             // Rule at src/isa/x64/lower.isle line 2304.
7913                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7914                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
7915                             let expr2_0 = constructor_x64_divsd(ctx, expr0_0, &expr1_0)?;
7916                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7917                             return Some(expr3_0);
7918                         }
7919                         &Opcode::Fmin => {
7920                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7921                             // Rule at src/isa/x64/lower.isle line 2325.
7922                             let expr0_0: Type = F64;
7923                             let expr1_0: bool = true;
7924                             let expr2_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7925                             let expr3_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
7926                             let expr4_0 = constructor_xmm_min_max_seq(
7927                                 ctx, expr0_0, expr1_0, expr2_0, expr3_0,
7928                             )?;
7929                             let expr5_0 = constructor_output_xmm(ctx, expr4_0)?;
7930                             return Some(expr5_0);
7931                         }
7932                         &Opcode::FminPseudo => {
7933                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7934                             // Rule at src/isa/x64/lower.isle line 2494.
7935                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
7936                             let expr1_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7937                             let expr2_0 = constructor_x64_minsd(ctx, expr0_0, expr1_0)?;
7938                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7939                             return Some(expr3_0);
7940                         }
7941                         &Opcode::Fmax => {
7942                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7943                             // Rule at src/isa/x64/lower.isle line 2397.
7944                             let expr0_0: Type = F64;
7945                             let expr1_0: bool = false;
7946                             let expr2_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7947                             let expr3_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
7948                             let expr4_0 = constructor_xmm_min_max_seq(
7949                                 ctx, expr0_0, expr1_0, expr2_0, expr3_0,
7950                             )?;
7951                             let expr5_0 = constructor_output_xmm(ctx, expr4_0)?;
7952                             return Some(expr5_0);
7953                         }
7954                         &Opcode::FmaxPseudo => {
7955                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
7956                             // Rule at src/isa/x64/lower.isle line 2505.
7957                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
7958                             let expr1_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
7959                             let expr2_0 = constructor_x64_maxsd(ctx, expr0_0, expr1_0)?;
7960                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7961                             return Some(expr3_0);
7962                         }
7963                         _ => {}
7964                     }
7965                 }
7966                 &InstructionData::Unary {
7967                     opcode: ref pattern5_0,
7968                     arg: pattern5_1,
7969                 } => {
7970                     if let &Opcode::Sqrt = pattern5_0 {
7971                         // Rule at src/isa/x64/lower.isle line 2314.
7972                         let expr0_0 = constructor_put_in_xmm(ctx, pattern5_1)?;
7973                         let expr1_0 = constructor_x64_sqrtsd(ctx, expr0_0)?;
7974                         let expr2_0 = constructor_output_xmm(ctx, expr1_0)?;
7975                         return Some(expr2_0);
7976                     }
7977                 }
7978                 &InstructionData::Load {
7979                     opcode: ref pattern5_0,
7980                     arg: pattern5_1,
7981                     flags: pattern5_2,
7982                     offset: pattern5_3,
7983                 } => {
7984                     if let &Opcode::Load = pattern5_0 {
7985                         // Rule at src/isa/x64/lower.isle line 2548.
7986                         let expr0_0 =
7987                             constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
7988                         let expr1_0 = constructor_amode_to_xmm_mem(ctx, &expr0_0)?;
7989                         let expr2_0 = constructor_x64_movsd_load(ctx, &expr1_0)?;
7990                         let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
7991                         return Some(expr3_0);
7992                     }
7993                 }
7994                 _ => {}
7995             }
7996         }
7997         if pattern2_0 == I8X16 {
7998             let pattern4_0 = C::inst_data(ctx, pattern0_0);
7999             match &pattern4_0 {
8000                 &InstructionData::Binary {
8001                     opcode: ref pattern5_0,
8002                     args: ref pattern5_1,
8003                 } => {
8004                     match pattern5_0 {
8005                         &Opcode::Imin => {
8006                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
8007                             // Rule at src/isa/x64/lower.isle line 1405.
8008                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
8009                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
8010                             let expr2_0 = constructor_x64_pminsb(ctx, expr0_0, &expr1_0)?;
8011                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8012                             return Some(expr3_0);
8013                         }
8014                         &Opcode::Umin => {
8015                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
8016                             // Rule at src/isa/x64/lower.isle line 1427.
8017                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
8018                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
8019                             let expr2_0 = constructor_x64_pminub(ctx, expr0_0, &expr1_0)?;
8020                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8021                             return Some(expr3_0);
8022                         }
8023                         &Opcode::Imax => {
8024                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
8025                             // Rule at src/isa/x64/lower.isle line 1394.
8026                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
8027                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
8028                             let expr2_0 = constructor_x64_pmaxsb(ctx, expr0_0, &expr1_0)?;
8029                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8030                             return Some(expr3_0);
8031                         }
8032                         &Opcode::Umax => {
8033                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
8034                             // Rule at src/isa/x64/lower.isle line 1416.
8035                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
8036                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
8037                             let expr2_0 = constructor_x64_pmaxub(ctx, expr0_0, &expr1_0)?;
8038                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8039                             return Some(expr3_0);
8040                         }
8041                         &Opcode::Ishl => {
8042                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
8043                             // Rule at src/isa/x64/lower.isle line 534.
8044                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
8045                             let expr1_0 = C::put_in_reg_mem_imm(ctx, pattern7_1);
8046                             let expr2_0 = constructor_mov_rmi_to_xmm(ctx, &expr1_0)?;
8047                             let expr3_0 = constructor_x64_psllw(ctx, expr0_0, &expr2_0)?;
8048                             let expr4_0 = C::put_in_reg_mem_imm(ctx, pattern7_1);
8049                             let expr5_0 = constructor_ishl_i8x16_mask(ctx, &expr4_0)?;
8050                             let expr6_0: Type = I8X16;
8051                             let expr7_0 = ExtKind::None;
8052                             let expr8_0 = constructor_x64_load(ctx, expr6_0, &expr5_0, &expr7_0)?;
8053                             let expr9_0: Type = I8X16;
8054                             let expr10_0 = RegMem::Reg { reg: expr8_0 };
8055                             let expr11_0 = C::reg_mem_to_xmm_mem(ctx, &expr10_0);
8056                             let expr12_0 = constructor_sse_and(ctx, expr9_0, expr3_0, &expr11_0)?;
8057                             let expr13_0 = constructor_output_xmm(ctx, expr12_0)?;
8058                             return Some(expr13_0);
8059                         }
8060                         &Opcode::Ushr => {
8061                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
8062                             // Rule at src/isa/x64/lower.isle line 633.
8063                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
8064                             let expr1_0 = C::put_in_reg_mem_imm(ctx, pattern7_1);
8065                             let expr2_0 = constructor_mov_rmi_to_xmm(ctx, &expr1_0)?;
8066                             let expr3_0 = constructor_x64_psrlw(ctx, expr0_0, &expr2_0)?;
8067                             let expr4_0 = C::put_in_reg_mem_imm(ctx, pattern7_1);
8068                             let expr5_0 = constructor_ushr_i8x16_mask(ctx, &expr4_0)?;
8069                             let expr6_0: Type = I8X16;
8070                             let expr7_0 = ExtKind::None;
8071                             let expr8_0 = constructor_x64_load(ctx, expr6_0, &expr5_0, &expr7_0)?;
8072                             let expr9_0: Type = I8X16;
8073                             let expr10_0 = RegMem::Reg { reg: expr8_0 };
8074                             let expr11_0 = C::reg_mem_to_xmm_mem(ctx, &expr10_0);
8075                             let expr12_0 = constructor_sse_and(ctx, expr9_0, expr3_0, &expr11_0)?;
8076                             let expr13_0 = constructor_output_xmm(ctx, expr12_0)?;
8077                             return Some(expr13_0);
8078                         }
8079                         &Opcode::Sshr => {
8080                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
8081                             let pattern8_0 = C::value_type(ctx, pattern7_1);
8082                             // Rule at src/isa/x64/lower.isle line 749.
8083                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
8084                             let expr1_0 = C::xmm_to_xmm_mem(ctx, expr0_0);
8085                             let expr2_0 = constructor_x64_punpcklbw(ctx, expr0_0, &expr1_0)?;
8086                             let expr3_0 = C::xmm_to_xmm_mem(ctx, expr0_0);
8087                             let expr4_0 = constructor_x64_punpckhbw(ctx, expr0_0, &expr3_0)?;
8088                             let expr5_0 = C::put_in_reg_mem_imm(ctx, pattern7_1);
8089                             let expr6_0 =
8090                                 constructor_sshr_i8x16_bigger_shift(ctx, pattern8_0, &expr5_0)?;
8091                             let expr7_0 = constructor_x64_psraw(ctx, expr2_0, &expr6_0)?;
8092                             let expr8_0 = constructor_x64_psraw(ctx, expr4_0, &expr6_0)?;
8093                             let expr9_0 = C::xmm_to_xmm_mem(ctx, expr8_0);
8094                             let expr10_0 = constructor_x64_packsswb(ctx, expr7_0, &expr9_0)?;
8095                             let expr11_0 = constructor_output_xmm(ctx, expr10_0)?;
8096                             return Some(expr11_0);
8097                         }
8098                         _ => {}
8099                     }
8100                 }
8101                 &InstructionData::Unary {
8102                     opcode: ref pattern5_0,
8103                     arg: pattern5_1,
8104                 } => {
8105                     match pattern5_0 {
8106                         &Opcode::Ineg => {
8107                             // Rule at src/isa/x64/lower.isle line 889.
8108                             let expr0_0: Type = I8X16;
8109                             let expr1_0: u64 = 0;
8110                             let expr2_0 = constructor_imm(ctx, expr0_0, expr1_0)?;
8111                             let expr3_0 = C::xmm_new(ctx, expr2_0);
8112                             let expr4_0 = constructor_put_in_xmm_mem(ctx, pattern5_1)?;
8113                             let expr5_0 = constructor_x64_psubb(ctx, expr3_0, &expr4_0)?;
8114                             let expr6_0 = constructor_output_xmm(ctx, expr5_0)?;
8115                             return Some(expr6_0);
8116                         }
8117                         &Opcode::Iabs => {
8118                             // Rule at src/isa/x64/lower.isle line 1210.
8119                             let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern5_1)?;
8120                             let expr1_0 = constructor_x64_pabsb(ctx, &expr0_0)?;
8121                             let expr2_0 = constructor_output_xmm(ctx, expr1_0)?;
8122                             return Some(expr2_0);
8123                         }
8124                         &Opcode::Popcnt => {
8125                             // Rule at src/isa/x64/lower.isle line 2002.
8126                             let expr0_0 = C::popcount_4bit_table(ctx);
8127                             let expr1_0: Type = I8X16;
8128                             let expr2_0 = C::popcount_low_mask(ctx);
8129                             let expr3_0 = constructor_x64_xmm_load_const(ctx, expr1_0, expr2_0)?;
8130                             let expr4_0: Type = I8X16;
8131                             let expr5_0 = constructor_put_in_xmm(ctx, pattern5_1)?;
8132                             let expr6_0 = C::xmm_to_xmm_mem(ctx, expr3_0);
8133                             let expr7_0 = constructor_sse_and(ctx, expr4_0, expr5_0, &expr6_0)?;
8134                             let expr8_0 = constructor_put_in_xmm(ctx, pattern5_1)?;
8135                             let expr9_0: u32 = 4;
8136                             let expr10_0 = RegMemImm::Imm { simm32: expr9_0 };
8137                             let expr11_0 = constructor_mov_rmi_to_xmm(ctx, &expr10_0)?;
8138                             let expr12_0 = constructor_x64_psrlw(ctx, expr8_0, &expr11_0)?;
8139                             let expr13_0: Type = I8X16;
8140                             let expr14_0 = C::xmm_to_xmm_mem(ctx, expr3_0);
8141                             let expr15_0 = constructor_sse_and(ctx, expr13_0, expr12_0, &expr14_0)?;
8142                             let expr16_0: Type = I8X16;
8143                             let expr17_0 = C::popcount_4bit_table(ctx);
8144                             let expr18_0 = constructor_x64_xmm_load_const(ctx, expr16_0, expr17_0)?;
8145                             let expr19_0 = C::xmm_to_xmm_mem(ctx, expr7_0);
8146                             let expr20_0 = constructor_x64_pshufb(ctx, expr18_0, &expr19_0)?;
8147                             let expr21_0 = C::xmm_to_xmm_mem(ctx, expr15_0);
8148                             let expr22_0 = constructor_x64_pshufb(ctx, expr18_0, &expr21_0)?;
8149                             let expr23_0 = C::xmm_to_xmm_mem(ctx, expr22_0);
8150                             let expr24_0 = constructor_x64_paddb(ctx, expr20_0, &expr23_0)?;
8151                             let expr25_0 = constructor_output_xmm(ctx, expr24_0)?;
8152                             return Some(expr25_0);
8153                         }
8154                         _ => {}
8155                     }
8156                 }
8157                 _ => {}
8158             }
8159         }
8160         if pattern2_0 == I16X8 {
8161             let pattern4_0 = C::inst_data(ctx, pattern0_0);
8162             match &pattern4_0 {
8163                 &InstructionData::Binary {
8164                     opcode: ref pattern5_0,
8165                     args: ref pattern5_1,
8166                 } => {
8167                     match pattern5_0 {
8168                         &Opcode::Imin => {
8169                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
8170                             // Rule at src/isa/x64/lower.isle line 1408.
8171                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
8172                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
8173                             let expr2_0 = constructor_x64_pminsw(ctx, expr0_0, &expr1_0)?;
8174                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8175                             return Some(expr3_0);
8176                         }
8177                         &Opcode::Umin => {
8178                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
8179                             // Rule at src/isa/x64/lower.isle line 1430.
8180                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
8181                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
8182                             let expr2_0 = constructor_x64_pminuw(ctx, expr0_0, &expr1_0)?;
8183                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8184                             return Some(expr3_0);
8185                         }
8186                         &Opcode::Imax => {
8187                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
8188                             // Rule at src/isa/x64/lower.isle line 1397.
8189                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
8190                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
8191                             let expr2_0 = constructor_x64_pmaxsw(ctx, expr0_0, &expr1_0)?;
8192                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8193                             return Some(expr3_0);
8194                         }
8195                         &Opcode::Umax => {
8196                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
8197                             // Rule at src/isa/x64/lower.isle line 1419.
8198                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
8199                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
8200                             let expr2_0 = constructor_x64_pmaxuw(ctx, expr0_0, &expr1_0)?;
8201                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8202                             return Some(expr3_0);
8203                         }
8204                         &Opcode::Ishl => {
8205                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
8206                             // Rule at src/isa/x64/lower.isle line 576.
8207                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
8208                             let expr1_0 = C::put_in_reg_mem_imm(ctx, pattern7_1);
8209                             let expr2_0 = constructor_mov_rmi_to_xmm(ctx, &expr1_0)?;
8210                             let expr3_0 = constructor_x64_psllw(ctx, expr0_0, &expr2_0)?;
8211                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
8212                             return Some(expr4_0);
8213                         }
8214                         &Opcode::Ushr => {
8215                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
8216                             // Rule at src/isa/x64/lower.isle line 678.
8217                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
8218                             let expr1_0 = C::put_in_reg_mem_imm(ctx, pattern7_1);
8219                             let expr2_0 = constructor_mov_rmi_to_xmm(ctx, &expr1_0)?;
8220                             let expr3_0 = constructor_x64_psrlw(ctx, expr0_0, &expr2_0)?;
8221                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
8222                             return Some(expr4_0);
8223                         }
8224                         &Opcode::Sshr => {
8225                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
8226                             // Rule at src/isa/x64/lower.isle line 776.
8227                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
8228                             let expr1_0 = C::put_in_reg_mem_imm(ctx, pattern7_1);
8229                             let expr2_0 = constructor_mov_rmi_to_xmm(ctx, &expr1_0)?;
8230                             let expr3_0 = constructor_x64_psraw(ctx, expr0_0, &expr2_0)?;
8231                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
8232                             return Some(expr4_0);
8233                         }
8234                         _ => {}
8235                     }
8236                 }
8237                 &InstructionData::Unary {
8238                     opcode: ref pattern5_0,
8239                     arg: pattern5_1,
8240                 } => {
8241                     match pattern5_0 {
8242                         &Opcode::Ineg => {
8243                             // Rule at src/isa/x64/lower.isle line 892.
8244                             let expr0_0: Type = I16X8;
8245                             let expr1_0: u64 = 0;
8246                             let expr2_0 = constructor_imm(ctx, expr0_0, expr1_0)?;
8247                             let expr3_0 = C::xmm_new(ctx, expr2_0);
8248                             let expr4_0 = constructor_put_in_xmm_mem(ctx, pattern5_1)?;
8249                             let expr5_0 = constructor_x64_psubw(ctx, expr3_0, &expr4_0)?;
8250                             let expr6_0 = constructor_output_xmm(ctx, expr5_0)?;
8251                             return Some(expr6_0);
8252                         }
8253                         &Opcode::Iabs => {
8254                             // Rule at src/isa/x64/lower.isle line 1213.
8255                             let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern5_1)?;
8256                             let expr1_0 = constructor_x64_pabsw(ctx, &expr0_0)?;
8257                             let expr2_0 = constructor_output_xmm(ctx, expr1_0)?;
8258                             return Some(expr2_0);
8259                         }
8260                         _ => {}
8261                     }
8262                 }
8263                 &InstructionData::Load {
8264                     opcode: ref pattern5_0,
8265                     arg: pattern5_1,
8266                     flags: pattern5_2,
8267                     offset: pattern5_3,
8268                 } => {
8269                     match pattern5_0 {
8270                         &Opcode::Uload8x8 => {
8271                             // Rule at src/isa/x64/lower.isle line 2570.
8272                             let expr0_0 =
8273                                 constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
8274                             let expr1_0 = constructor_amode_to_xmm_mem(ctx, &expr0_0)?;
8275                             let expr2_0 = constructor_x64_pmovzxbw(ctx, &expr1_0)?;
8276                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8277                             return Some(expr3_0);
8278                         }
8279                         &Opcode::Sload8x8 => {
8280                             // Rule at src/isa/x64/lower.isle line 2568.
8281                             let expr0_0 =
8282                                 constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
8283                             let expr1_0 = constructor_amode_to_xmm_mem(ctx, &expr0_0)?;
8284                             let expr2_0 = constructor_x64_pmovsxbw(ctx, &expr1_0)?;
8285                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8286                             return Some(expr3_0);
8287                         }
8288                         _ => {}
8289                     }
8290                 }
8291                 _ => {}
8292             }
8293         }
8294         if pattern2_0 == I32X4 {
8295             let pattern4_0 = C::inst_data(ctx, pattern0_0);
8296             match &pattern4_0 {
8297                 &InstructionData::Binary {
8298                     opcode: ref pattern5_0,
8299                     args: ref pattern5_1,
8300                 } => {
8301                     match pattern5_0 {
8302                         &Opcode::Imin => {
8303                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
8304                             // Rule at src/isa/x64/lower.isle line 1411.
8305                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
8306                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
8307                             let expr2_0 = constructor_x64_pminsd(ctx, expr0_0, &expr1_0)?;
8308                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8309                             return Some(expr3_0);
8310                         }
8311                         &Opcode::Umin => {
8312                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
8313                             // Rule at src/isa/x64/lower.isle line 1433.
8314                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
8315                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
8316                             let expr2_0 = constructor_x64_pminud(ctx, expr0_0, &expr1_0)?;
8317                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8318                             return Some(expr3_0);
8319                         }
8320                         &Opcode::Imax => {
8321                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
8322                             // Rule at src/isa/x64/lower.isle line 1400.
8323                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
8324                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
8325                             let expr2_0 = constructor_x64_pmaxsd(ctx, expr0_0, &expr1_0)?;
8326                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8327                             return Some(expr3_0);
8328                         }
8329                         &Opcode::Umax => {
8330                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
8331                             // Rule at src/isa/x64/lower.isle line 1422.
8332                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
8333                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
8334                             let expr2_0 = constructor_x64_pmaxud(ctx, expr0_0, &expr1_0)?;
8335                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8336                             return Some(expr3_0);
8337                         }
8338                         &Opcode::Ishl => {
8339                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
8340                             // Rule at src/isa/x64/lower.isle line 579.
8341                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
8342                             let expr1_0 = C::put_in_reg_mem_imm(ctx, pattern7_1);
8343                             let expr2_0 = constructor_mov_rmi_to_xmm(ctx, &expr1_0)?;
8344                             let expr3_0 = constructor_x64_pslld(ctx, expr0_0, &expr2_0)?;
8345                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
8346                             return Some(expr4_0);
8347                         }
8348                         &Opcode::Ushr => {
8349                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
8350                             // Rule at src/isa/x64/lower.isle line 681.
8351                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
8352                             let expr1_0 = C::put_in_reg_mem_imm(ctx, pattern7_1);
8353                             let expr2_0 = constructor_mov_rmi_to_xmm(ctx, &expr1_0)?;
8354                             let expr3_0 = constructor_x64_psrld(ctx, expr0_0, &expr2_0)?;
8355                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
8356                             return Some(expr4_0);
8357                         }
8358                         &Opcode::Sshr => {
8359                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
8360                             // Rule at src/isa/x64/lower.isle line 779.
8361                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
8362                             let expr1_0 = C::put_in_reg_mem_imm(ctx, pattern7_1);
8363                             let expr2_0 = constructor_mov_rmi_to_xmm(ctx, &expr1_0)?;
8364                             let expr3_0 = constructor_x64_psrad(ctx, expr0_0, &expr2_0)?;
8365                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
8366                             return Some(expr4_0);
8367                         }
8368                         &Opcode::WideningPairwiseDotProductS => {
8369                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
8370                             // Rule at src/isa/x64/lower.isle line 2259.
8371                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
8372                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
8373                             let expr2_0 = constructor_x64_pmaddwd(ctx, expr0_0, &expr1_0)?;
8374                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8375                             return Some(expr3_0);
8376                         }
8377                         _ => {}
8378                     }
8379                 }
8380                 &InstructionData::Unary {
8381                     opcode: ref pattern5_0,
8382                     arg: pattern5_1,
8383                 } => {
8384                     match pattern5_0 {
8385                         &Opcode::Ineg => {
8386                             // Rule at src/isa/x64/lower.isle line 895.
8387                             let expr0_0: Type = I32X4;
8388                             let expr1_0: u64 = 0;
8389                             let expr2_0 = constructor_imm(ctx, expr0_0, expr1_0)?;
8390                             let expr3_0 = C::xmm_new(ctx, expr2_0);
8391                             let expr4_0 = constructor_put_in_xmm_mem(ctx, pattern5_1)?;
8392                             let expr5_0 = constructor_x64_psubd(ctx, expr3_0, &expr4_0)?;
8393                             let expr6_0 = constructor_output_xmm(ctx, expr5_0)?;
8394                             return Some(expr6_0);
8395                         }
8396                         &Opcode::Iabs => {
8397                             // Rule at src/isa/x64/lower.isle line 1216.
8398                             let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern5_1)?;
8399                             let expr1_0 = constructor_x64_pabsd(ctx, &expr0_0)?;
8400                             let expr2_0 = constructor_output_xmm(ctx, expr1_0)?;
8401                             return Some(expr2_0);
8402                         }
8403                         _ => {}
8404                     }
8405                 }
8406                 &InstructionData::Load {
8407                     opcode: ref pattern5_0,
8408                     arg: pattern5_1,
8409                     flags: pattern5_2,
8410                     offset: pattern5_3,
8411                 } => {
8412                     match pattern5_0 {
8413                         &Opcode::Uload16x4 => {
8414                             // Rule at src/isa/x64/lower.isle line 2574.
8415                             let expr0_0 =
8416                                 constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
8417                             let expr1_0 = constructor_amode_to_xmm_mem(ctx, &expr0_0)?;
8418                             let expr2_0 = constructor_x64_pmovzxwd(ctx, &expr1_0)?;
8419                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8420                             return Some(expr3_0);
8421                         }
8422                         &Opcode::Sload16x4 => {
8423                             // Rule at src/isa/x64/lower.isle line 2572.
8424                             let expr0_0 =
8425                                 constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
8426                             let expr1_0 = constructor_amode_to_xmm_mem(ctx, &expr0_0)?;
8427                             let expr2_0 = constructor_x64_pmovsxwd(ctx, &expr1_0)?;
8428                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8429                             return Some(expr3_0);
8430                         }
8431                         _ => {}
8432                     }
8433                 }
8434                 _ => {}
8435             }
8436         }
8437         if pattern2_0 == I64X2 {
8438             let pattern4_0 = C::inst_data(ctx, pattern0_0);
8439             match &pattern4_0 {
8440                 &InstructionData::Binary {
8441                     opcode: ref pattern5_0,
8442                     args: ref pattern5_1,
8443                 } => {
8444                     match pattern5_0 {
8445                         &Opcode::Ishl => {
8446                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
8447                             // Rule at src/isa/x64/lower.isle line 582.
8448                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
8449                             let expr1_0 = C::put_in_reg_mem_imm(ctx, pattern7_1);
8450                             let expr2_0 = constructor_mov_rmi_to_xmm(ctx, &expr1_0)?;
8451                             let expr3_0 = constructor_x64_psllq(ctx, expr0_0, &expr2_0)?;
8452                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
8453                             return Some(expr4_0);
8454                         }
8455                         &Opcode::Ushr => {
8456                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
8457                             // Rule at src/isa/x64/lower.isle line 684.
8458                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
8459                             let expr1_0 = C::put_in_reg_mem_imm(ctx, pattern7_1);
8460                             let expr2_0 = constructor_mov_rmi_to_xmm(ctx, &expr1_0)?;
8461                             let expr3_0 = constructor_x64_psrlq(ctx, expr0_0, &expr2_0)?;
8462                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
8463                             return Some(expr4_0);
8464                         }
8465                         &Opcode::Sshr => {
8466                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
8467                             // Rule at src/isa/x64/lower.isle line 790.
8468                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
8469                             let expr1_0: Type = I64;
8470                             let expr2_0: u8 = 0;
8471                             let expr3_0 = constructor_x64_pextrd(ctx, expr1_0, expr0_0, expr2_0)?;
8472                             let expr4_0: Type = I64;
8473                             let expr5_0: u8 = 1;
8474                             let expr6_0 = constructor_x64_pextrd(ctx, expr4_0, expr0_0, expr5_0)?;
8475                             let expr7_0: Type = I64;
8476                             let expr8_0 = C::put_masked_in_imm8_gpr(ctx, pattern7_1, expr7_0);
8477                             let expr9_0: Type = I64;
8478                             let expr10_0 = constructor_x64_sar(ctx, expr9_0, expr3_0, &expr8_0)?;
8479                             let expr11_0: Type = I64;
8480                             let expr12_0 = constructor_x64_sar(ctx, expr11_0, expr6_0, &expr8_0)?;
8481                             let expr13_0 = C::gpr_to_gpr_mem(ctx, expr10_0);
8482                             let expr14_0 = C::gpr_to_gpr_mem(ctx, expr12_0);
8483                             let expr15_0 =
8484                                 constructor_make_i64x2_from_lanes(ctx, &expr13_0, &expr14_0)?;
8485                             let expr16_0 = constructor_output_xmm(ctx, expr15_0)?;
8486                             return Some(expr16_0);
8487                         }
8488                         _ => {}
8489                     }
8490                 }
8491                 &InstructionData::Unary {
8492                     opcode: ref pattern5_0,
8493                     arg: pattern5_1,
8494                 } => {
8495                     match pattern5_0 {
8496                         &Opcode::Ineg => {
8497                             // Rule at src/isa/x64/lower.isle line 898.
8498                             let expr0_0: Type = I64X2;
8499                             let expr1_0: u64 = 0;
8500                             let expr2_0 = constructor_imm(ctx, expr0_0, expr1_0)?;
8501                             let expr3_0 = C::xmm_new(ctx, expr2_0);
8502                             let expr4_0 = constructor_put_in_xmm_mem(ctx, pattern5_1)?;
8503                             let expr5_0 = constructor_x64_psubq(ctx, expr3_0, &expr4_0)?;
8504                             let expr6_0 = constructor_output_xmm(ctx, expr5_0)?;
8505                             return Some(expr6_0);
8506                         }
8507                         &Opcode::Iabs => {
8508                             // Rule at src/isa/x64/lower.isle line 1230.
8509                             let expr0_0 = constructor_put_in_xmm(ctx, pattern5_1)?;
8510                             let expr1_0: Type = I64X2;
8511                             let expr2_0: u64 = 0;
8512                             let expr3_0 = constructor_imm(ctx, expr1_0, expr2_0)?;
8513                             let expr4_0 = C::xmm_new(ctx, expr3_0);
8514                             let expr5_0 = C::xmm_to_xmm_mem(ctx, expr0_0);
8515                             let expr6_0 = constructor_x64_psubq(ctx, expr4_0, &expr5_0)?;
8516                             let expr7_0 = C::xmm_to_xmm_mem(ctx, expr0_0);
8517                             let expr8_0 =
8518                                 constructor_x64_blendvpd(ctx, expr6_0, &expr7_0, expr6_0)?;
8519                             let expr9_0 = constructor_output_xmm(ctx, expr8_0)?;
8520                             return Some(expr9_0);
8521                         }
8522                         _ => {}
8523                     }
8524                 }
8525                 &InstructionData::Load {
8526                     opcode: ref pattern5_0,
8527                     arg: pattern5_1,
8528                     flags: pattern5_2,
8529                     offset: pattern5_3,
8530                 } => {
8531                     match pattern5_0 {
8532                         &Opcode::Uload32x2 => {
8533                             // Rule at src/isa/x64/lower.isle line 2578.
8534                             let expr0_0 =
8535                                 constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
8536                             let expr1_0 = constructor_amode_to_xmm_mem(ctx, &expr0_0)?;
8537                             let expr2_0 = constructor_x64_pmovzxdq(ctx, &expr1_0)?;
8538                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8539                             return Some(expr3_0);
8540                         }
8541                         &Opcode::Sload32x2 => {
8542                             // Rule at src/isa/x64/lower.isle line 2576.
8543                             let expr0_0 =
8544                                 constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
8545                             let expr1_0 = constructor_amode_to_xmm_mem(ctx, &expr0_0)?;
8546                             let expr2_0 = constructor_x64_pmovsxdq(ctx, &expr1_0)?;
8547                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8548                             return Some(expr3_0);
8549                         }
8550                         _ => {}
8551                     }
8552                 }
8553                 _ => {}
8554             }
8555         }
8556         if pattern2_0 == F32X4 {
8557             let pattern4_0 = C::inst_data(ctx, pattern0_0);
8558             match &pattern4_0 {
8559                 &InstructionData::Binary {
8560                     opcode: ref pattern5_0,
8561                     args: ref pattern5_1,
8562                 } => {
8563                     match pattern5_0 {
8564                         &Opcode::Fadd => {
8565                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
8566                             // Rule at src/isa/x64/lower.isle line 2273.
8567                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
8568                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
8569                             let expr2_0 = constructor_x64_addps(ctx, expr0_0, &expr1_0)?;
8570                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8571                             return Some(expr3_0);
8572                         }
8573                         &Opcode::Fsub => {
8574                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
8575                             // Rule at src/isa/x64/lower.isle line 2284.
8576                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
8577                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
8578                             let expr2_0 = constructor_x64_subps(ctx, expr0_0, &expr1_0)?;
8579                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8580                             return Some(expr3_0);
8581                         }
8582                         &Opcode::Fmul => {
8583                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
8584                             // Rule at src/isa/x64/lower.isle line 2295.
8585                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
8586                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
8587                             let expr2_0 = constructor_x64_mulps(ctx, expr0_0, &expr1_0)?;
8588                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8589                             return Some(expr3_0);
8590                         }
8591                         &Opcode::Fdiv => {
8592                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
8593                             // Rule at src/isa/x64/lower.isle line 2306.
8594                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
8595                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
8596                             let expr2_0 = constructor_x64_divps(ctx, expr0_0, &expr1_0)?;
8597                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8598                             return Some(expr3_0);
8599                         }
8600                         &Opcode::Fmin => {
8601                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
8602                             // Rule at src/isa/x64/lower.isle line 2340.
8603                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
8604                             let expr1_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
8605                             let expr2_0 = constructor_x64_minps(ctx, expr0_0, expr1_0)?;
8606                             let expr3_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
8607                             let expr4_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
8608                             let expr5_0 = constructor_x64_minps(ctx, expr3_0, expr4_0)?;
8609                             let expr6_0 = C::xmm_to_xmm_mem(ctx, expr5_0);
8610                             let expr7_0 = constructor_x64_orps(ctx, expr2_0, &expr6_0)?;
8611                             let expr8_0 = C::xmm_to_xmm_mem(ctx, expr5_0);
8612                             let expr9_0 = FcmpImm::Unordered;
8613                             let expr10_0 = constructor_x64_cmpps(ctx, expr7_0, &expr8_0, &expr9_0)?;
8614                             let expr11_0 = C::xmm_to_xmm_mem(ctx, expr10_0);
8615                             let expr12_0 = constructor_x64_orps(ctx, expr7_0, &expr11_0)?;
8616                             let expr13_0: u32 = 10;
8617                             let expr14_0 = RegMemImm::Imm { simm32: expr13_0 };
8618                             let expr15_0 = constructor_mov_rmi_to_xmm(ctx, &expr14_0)?;
8619                             let expr16_0 = constructor_x64_psrld(ctx, expr10_0, &expr15_0)?;
8620                             let expr17_0 = C::xmm_to_xmm_mem(ctx, expr12_0);
8621                             let expr18_0 = constructor_x64_andnps(ctx, expr16_0, &expr17_0)?;
8622                             let expr19_0 = constructor_output_xmm(ctx, expr18_0)?;
8623                             return Some(expr19_0);
8624                         }
8625                         &Opcode::FminPseudo => {
8626                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
8627                             // Rule at src/isa/x64/lower.isle line 2496.
8628                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
8629                             let expr1_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
8630                             let expr2_0 = constructor_x64_minps(ctx, expr0_0, expr1_0)?;
8631                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8632                             return Some(expr3_0);
8633                         }
8634                         &Opcode::Fmax => {
8635                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
8636                             // Rule at src/isa/x64/lower.isle line 2403.
8637                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
8638                             let expr1_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
8639                             let expr2_0 = constructor_x64_maxps(ctx, expr0_0, expr1_0)?;
8640                             let expr3_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
8641                             let expr4_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
8642                             let expr5_0 = constructor_x64_maxps(ctx, expr3_0, expr4_0)?;
8643                             let expr6_0 = C::xmm_to_xmm_mem(ctx, expr5_0);
8644                             let expr7_0 = constructor_x64_xorps(ctx, expr2_0, &expr6_0)?;
8645                             let expr8_0 = C::xmm_to_xmm_mem(ctx, expr7_0);
8646                             let expr9_0 = constructor_x64_orps(ctx, expr2_0, &expr8_0)?;
8647                             let expr10_0 = C::xmm_to_xmm_mem(ctx, expr7_0);
8648                             let expr11_0 = constructor_x64_subps(ctx, expr9_0, &expr10_0)?;
8649                             let expr12_0 = C::xmm_to_xmm_mem(ctx, expr9_0);
8650                             let expr13_0 = FcmpImm::Unordered;
8651                             let expr14_0 =
8652                                 constructor_x64_cmpps(ctx, expr9_0, &expr12_0, &expr13_0)?;
8653                             let expr15_0: u32 = 10;
8654                             let expr16_0 = RegMemImm::Imm { simm32: expr15_0 };
8655                             let expr17_0 = constructor_mov_rmi_to_xmm(ctx, &expr16_0)?;
8656                             let expr18_0 = constructor_x64_psrld(ctx, expr14_0, &expr17_0)?;
8657                             let expr19_0 = C::xmm_to_xmm_mem(ctx, expr11_0);
8658                             let expr20_0 = constructor_x64_andnps(ctx, expr18_0, &expr19_0)?;
8659                             let expr21_0 = constructor_output_xmm(ctx, expr20_0)?;
8660                             return Some(expr21_0);
8661                         }
8662                         &Opcode::FmaxPseudo => {
8663                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
8664                             // Rule at src/isa/x64/lower.isle line 2507.
8665                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
8666                             let expr1_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
8667                             let expr2_0 = constructor_x64_maxps(ctx, expr0_0, expr1_0)?;
8668                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8669                             return Some(expr3_0);
8670                         }
8671                         _ => {}
8672                     }
8673                 }
8674                 &InstructionData::Unary {
8675                     opcode: ref pattern5_0,
8676                     arg: pattern5_1,
8677                 } => {
8678                     match pattern5_0 {
8679                         &Opcode::Sqrt => {
8680                             // Rule at src/isa/x64/lower.isle line 2316.
8681                             let expr0_0 = constructor_put_in_xmm(ctx, pattern5_1)?;
8682                             let expr1_0 = constructor_x64_sqrtps(ctx, expr0_0)?;
8683                             let expr2_0 = constructor_output_xmm(ctx, expr1_0)?;
8684                             return Some(expr2_0);
8685                         }
8686                         &Opcode::Fabs => {
8687                             // Rule at src/isa/x64/lower.isle line 1238.
8688                             let expr0_0 = constructor_put_in_xmm(ctx, pattern5_1)?;
8689                             let expr1_0: Type = F32X4;
8690                             let expr2_0 = constructor_vector_all_ones(ctx, expr1_0)?;
8691                             let expr3_0: u32 = 1;
8692                             let expr4_0 = RegMemImm::Imm { simm32: expr3_0 };
8693                             let expr5_0 = constructor_mov_rmi_to_xmm(ctx, &expr4_0)?;
8694                             let expr6_0 = constructor_x64_psrld(ctx, expr2_0, &expr5_0)?;
8695                             let expr7_0 = C::xmm_to_xmm_mem(ctx, expr6_0);
8696                             let expr8_0 = constructor_x64_andps(ctx, expr0_0, &expr7_0)?;
8697                             let expr9_0 = constructor_output_xmm(ctx, expr8_0)?;
8698                             return Some(expr9_0);
8699                         }
8700                         _ => {}
8701                     }
8702                 }
8703                 &InstructionData::Load {
8704                     opcode: ref pattern5_0,
8705                     arg: pattern5_1,
8706                     flags: pattern5_2,
8707                     offset: pattern5_3,
8708                 } => {
8709                     if let &Opcode::Load = pattern5_0 {
8710                         // Rule at src/isa/x64/lower.isle line 2550.
8711                         let expr0_0 =
8712                             constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
8713                         let expr1_0 = constructor_amode_to_xmm_mem(ctx, &expr0_0)?;
8714                         let expr2_0 = constructor_x64_movups(ctx, &expr1_0)?;
8715                         let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8716                         return Some(expr3_0);
8717                     }
8718                 }
8719                 _ => {}
8720             }
8721         }
8722         if pattern2_0 == F64X2 {
8723             let pattern4_0 = C::inst_data(ctx, pattern0_0);
8724             match &pattern4_0 {
8725                 &InstructionData::Binary {
8726                     opcode: ref pattern5_0,
8727                     args: ref pattern5_1,
8728                 } => {
8729                     match pattern5_0 {
8730                         &Opcode::Fadd => {
8731                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
8732                             // Rule at src/isa/x64/lower.isle line 2275.
8733                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
8734                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
8735                             let expr2_0 = constructor_x64_addpd(ctx, expr0_0, &expr1_0)?;
8736                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8737                             return Some(expr3_0);
8738                         }
8739                         &Opcode::Fsub => {
8740                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
8741                             // Rule at src/isa/x64/lower.isle line 2286.
8742                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
8743                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
8744                             let expr2_0 = constructor_x64_subpd(ctx, expr0_0, &expr1_0)?;
8745                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8746                             return Some(expr3_0);
8747                         }
8748                         &Opcode::Fmul => {
8749                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
8750                             // Rule at src/isa/x64/lower.isle line 2297.
8751                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
8752                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
8753                             let expr2_0 = constructor_x64_mulpd(ctx, expr0_0, &expr1_0)?;
8754                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8755                             return Some(expr3_0);
8756                         }
8757                         &Opcode::Fdiv => {
8758                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
8759                             // Rule at src/isa/x64/lower.isle line 2308.
8760                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
8761                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
8762                             let expr2_0 = constructor_x64_divpd(ctx, expr0_0, &expr1_0)?;
8763                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8764                             return Some(expr3_0);
8765                         }
8766                         &Opcode::Fmin => {
8767                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
8768                             // Rule at src/isa/x64/lower.isle line 2383.
8769                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
8770                             let expr1_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
8771                             let expr2_0 = constructor_x64_minpd(ctx, expr0_0, expr1_0)?;
8772                             let expr3_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
8773                             let expr4_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
8774                             let expr5_0 = constructor_x64_minpd(ctx, expr3_0, expr4_0)?;
8775                             let expr6_0 = C::xmm_to_xmm_mem(ctx, expr5_0);
8776                             let expr7_0 = constructor_x64_orpd(ctx, expr2_0, &expr6_0)?;
8777                             let expr8_0 = C::xmm_to_xmm_mem(ctx, expr5_0);
8778                             let expr9_0 = FcmpImm::Unordered;
8779                             let expr10_0 = constructor_x64_cmppd(ctx, expr2_0, &expr8_0, &expr9_0)?;
8780                             let expr11_0 = C::xmm_to_xmm_mem(ctx, expr10_0);
8781                             let expr12_0 = constructor_x64_orpd(ctx, expr7_0, &expr11_0)?;
8782                             let expr13_0: u32 = 13;
8783                             let expr14_0 = RegMemImm::Imm { simm32: expr13_0 };
8784                             let expr15_0 = constructor_mov_rmi_to_xmm(ctx, &expr14_0)?;
8785                             let expr16_0 = constructor_x64_psrlq(ctx, expr10_0, &expr15_0)?;
8786                             let expr17_0 = C::xmm_to_xmm_mem(ctx, expr12_0);
8787                             let expr18_0 = constructor_x64_andnpd(ctx, expr16_0, &expr17_0)?;
8788                             let expr19_0 = constructor_output_xmm(ctx, expr18_0)?;
8789                             return Some(expr19_0);
8790                         }
8791                         &Opcode::FminPseudo => {
8792                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
8793                             // Rule at src/isa/x64/lower.isle line 2498.
8794                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
8795                             let expr1_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
8796                             let expr2_0 = constructor_x64_minpd(ctx, expr0_0, expr1_0)?;
8797                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8798                             return Some(expr3_0);
8799                         }
8800                         &Opcode::Fmax => {
8801                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
8802                             // Rule at src/isa/x64/lower.isle line 2446.
8803                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
8804                             let expr1_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
8805                             let expr2_0 = constructor_x64_maxpd(ctx, expr0_0, expr1_0)?;
8806                             let expr3_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
8807                             let expr4_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
8808                             let expr5_0 = constructor_x64_maxpd(ctx, expr3_0, expr4_0)?;
8809                             let expr6_0 = C::xmm_to_xmm_mem(ctx, expr5_0);
8810                             let expr7_0 = constructor_x64_xorpd(ctx, expr2_0, &expr6_0)?;
8811                             let expr8_0 = C::xmm_to_xmm_mem(ctx, expr7_0);
8812                             let expr9_0 = constructor_x64_orpd(ctx, expr2_0, &expr8_0)?;
8813                             let expr10_0 = C::xmm_to_xmm_mem(ctx, expr7_0);
8814                             let expr11_0 = constructor_x64_subpd(ctx, expr9_0, &expr10_0)?;
8815                             let expr12_0 = C::xmm_to_xmm_mem(ctx, expr9_0);
8816                             let expr13_0 = FcmpImm::Unordered;
8817                             let expr14_0 =
8818                                 constructor_x64_cmppd(ctx, expr9_0, &expr12_0, &expr13_0)?;
8819                             let expr15_0: u32 = 13;
8820                             let expr16_0 = RegMemImm::Imm { simm32: expr15_0 };
8821                             let expr17_0 = constructor_mov_rmi_to_xmm(ctx, &expr16_0)?;
8822                             let expr18_0 = constructor_x64_psrlq(ctx, expr14_0, &expr17_0)?;
8823                             let expr19_0 = C::xmm_to_xmm_mem(ctx, expr11_0);
8824                             let expr20_0 = constructor_x64_andnpd(ctx, expr18_0, &expr19_0)?;
8825                             let expr21_0 = constructor_output_xmm(ctx, expr20_0)?;
8826                             return Some(expr21_0);
8827                         }
8828                         &Opcode::FmaxPseudo => {
8829                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
8830                             // Rule at src/isa/x64/lower.isle line 2509.
8831                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
8832                             let expr1_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
8833                             let expr2_0 = constructor_x64_maxpd(ctx, expr0_0, expr1_0)?;
8834                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8835                             return Some(expr3_0);
8836                         }
8837                         _ => {}
8838                     }
8839                 }
8840                 &InstructionData::Unary {
8841                     opcode: ref pattern5_0,
8842                     arg: pattern5_1,
8843                 } => {
8844                     match pattern5_0 {
8845                         &Opcode::Sqrt => {
8846                             // Rule at src/isa/x64/lower.isle line 2318.
8847                             let expr0_0 = constructor_put_in_xmm(ctx, pattern5_1)?;
8848                             let expr1_0 = constructor_x64_sqrtpd(ctx, expr0_0)?;
8849                             let expr2_0 = constructor_output_xmm(ctx, expr1_0)?;
8850                             return Some(expr2_0);
8851                         }
8852                         &Opcode::Fabs => {
8853                             // Rule at src/isa/x64/lower.isle line 1244.
8854                             let expr0_0 = constructor_put_in_xmm(ctx, pattern5_1)?;
8855                             let expr1_0: Type = F64X2;
8856                             let expr2_0 = constructor_vector_all_ones(ctx, expr1_0)?;
8857                             let expr3_0: u32 = 1;
8858                             let expr4_0 = RegMemImm::Imm { simm32: expr3_0 };
8859                             let expr5_0 = constructor_mov_rmi_to_xmm(ctx, &expr4_0)?;
8860                             let expr6_0 = constructor_x64_psrlq(ctx, expr2_0, &expr5_0)?;
8861                             let expr7_0 = C::xmm_to_xmm_mem(ctx, expr6_0);
8862                             let expr8_0 = constructor_x64_andpd(ctx, expr0_0, &expr7_0)?;
8863                             let expr9_0 = constructor_output_xmm(ctx, expr8_0)?;
8864                             return Some(expr9_0);
8865                         }
8866                         _ => {}
8867                     }
8868                 }
8869                 &InstructionData::Load {
8870                     opcode: ref pattern5_0,
8871                     arg: pattern5_1,
8872                     flags: pattern5_2,
8873                     offset: pattern5_3,
8874                 } => {
8875                     if let &Opcode::Load = pattern5_0 {
8876                         // Rule at src/isa/x64/lower.isle line 2552.
8877                         let expr0_0 =
8878                             constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
8879                         let expr1_0 = constructor_amode_to_xmm_mem(ctx, &expr0_0)?;
8880                         let expr2_0 = constructor_x64_movupd(ctx, &expr1_0)?;
8881                         let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8882                         return Some(expr3_0);
8883                     }
8884                 }
8885                 _ => {}
8886             }
8887         }
8888         let pattern3_0 = C::inst_data(ctx, pattern0_0);
8889         match &pattern3_0 {
8890             &InstructionData::NullAry {
8891                 opcode: ref pattern4_0,
8892             } => {
8893                 if let &Opcode::Null = pattern4_0 {
8894                     // Rule at src/isa/x64/lower.isle line 56.
8895                     let expr0_0: u64 = 0;
8896                     let expr1_0 = constructor_imm(ctx, pattern2_0, expr0_0)?;
8897                     let expr2_0 = constructor_output_reg(ctx, expr1_0)?;
8898                     return Some(expr2_0);
8899                 }
8900             }
8901             &InstructionData::Binary {
8902                 opcode: ref pattern4_0,
8903                 args: ref pattern4_1,
8904             } => {
8905                 if let &Opcode::BandNot = pattern4_0 {
8906                     let (pattern6_0, pattern6_1) = C::unpack_value_array_2(ctx, pattern4_1);
8907                     // Rule at src/isa/x64/lower.isle line 1205.
8908                     let expr0_0 = constructor_put_in_xmm(ctx, pattern6_1)?;
8909                     let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern6_0)?;
8910                     let expr2_0 = constructor_sse_and_not(ctx, pattern2_0, expr0_0, &expr1_0)?;
8911                     let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
8912                     return Some(expr3_0);
8913                 }
8914             }
8915             &InstructionData::Ternary {
8916                 opcode: ref pattern4_0,
8917                 args: ref pattern4_1,
8918             } => {
8919                 if let &Opcode::Select = pattern4_0 {
8920                     let (pattern6_0, pattern6_1, pattern6_2) =
8921                         C::unpack_value_array_3(ctx, pattern4_1);
8922                     if let Some(pattern7_0) = C::def_inst(ctx, pattern6_0) {
8923                         let pattern8_0 = C::inst_data(ctx, pattern7_0);
8924                         match &pattern8_0 {
8925                             &InstructionData::FloatCompare {
8926                                 opcode: ref pattern9_0,
8927                                 args: ref pattern9_1,
8928                                 cond: ref pattern9_2,
8929                             } => {
8930                                 if let &Opcode::Fcmp = pattern9_0 {
8931                                     let (pattern11_0, pattern11_1) =
8932                                         C::unpack_value_array_2(ctx, pattern9_1);
8933                                     match pattern9_2 {
8934                                         &FloatCC::Equal => {
8935                                             // Rule at src/isa/x64/lower.isle line 1746.
8936                                             let expr0_0 = constructor_x64_ucomis(
8937                                                 ctx,
8938                                                 pattern11_0,
8939                                                 pattern11_1,
8940                                             )?;
8941                                             let expr1_0 = CC::NZ;
8942                                             let expr2_0 = CC::P;
8943                                             let expr3_0 = constructor_cmove_or_from_values(
8944                                                 ctx, pattern2_0, &expr1_0, &expr2_0, pattern6_2,
8945                                                 pattern6_1,
8946                                             )?;
8947                                             let expr4_0 =
8948                                                 constructor_with_flags(ctx, &expr0_0, &expr3_0)?;
8949                                             let expr5_0 = C::output(ctx, expr4_0);
8950                                             return Some(expr5_0);
8951                                         }
8952                                         &FloatCC::GreaterThan => {
8953                                             // Rule at src/isa/x64/lower.isle line 1698.
8954                                             let expr0_0 = constructor_x64_ucomis(
8955                                                 ctx,
8956                                                 pattern11_1,
8957                                                 pattern11_0,
8958                                             )?;
8959                                             let expr1_0 = CC::NBE;
8960                                             let expr2_0 = constructor_cmove_from_values(
8961                                                 ctx, pattern2_0, &expr1_0, pattern6_1, pattern6_2,
8962                                             )?;
8963                                             let expr3_0 =
8964                                                 constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
8965                                             let expr4_0 = C::output(ctx, expr3_0);
8966                                             return Some(expr4_0);
8967                                         }
8968                                         &FloatCC::GreaterThanOrEqual => {
8969                                             // Rule at src/isa/x64/lower.isle line 1701.
8970                                             let expr0_0 = constructor_x64_ucomis(
8971                                                 ctx,
8972                                                 pattern11_1,
8973                                                 pattern11_0,
8974                                             )?;
8975                                             let expr1_0 = CC::NB;
8976                                             let expr2_0 = constructor_cmove_from_values(
8977                                                 ctx, pattern2_0, &expr1_0, pattern6_1, pattern6_2,
8978                                             )?;
8979                                             let expr3_0 =
8980                                                 constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
8981                                             let expr4_0 = C::output(ctx, expr3_0);
8982                                             return Some(expr4_0);
8983                                         }
8984                                         &FloatCC::LessThan => {
8985                                             // Rule at src/isa/x64/lower.isle line 1721.
8986                                             let expr0_0 = constructor_x64_ucomis(
8987                                                 ctx,
8988                                                 pattern11_0,
8989                                                 pattern11_1,
8990                                             )?;
8991                                             let expr1_0 = CC::NBE;
8992                                             let expr2_0 = constructor_cmove_from_values(
8993                                                 ctx, pattern2_0, &expr1_0, pattern6_1, pattern6_2,
8994                                             )?;
8995                                             let expr3_0 =
8996                                                 constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
8997                                             let expr4_0 = C::output(ctx, expr3_0);
8998                                             return Some(expr4_0);
8999                                         }
9000                                         &FloatCC::LessThanOrEqual => {
9001                                             // Rule at src/isa/x64/lower.isle line 1724.
9002                                             let expr0_0 = constructor_x64_ucomis(
9003                                                 ctx,
9004                                                 pattern11_0,
9005                                                 pattern11_1,
9006                                             )?;
9007                                             let expr1_0 = CC::NB;
9008                                             let expr2_0 = constructor_cmove_from_values(
9009                                                 ctx, pattern2_0, &expr1_0, pattern6_1, pattern6_2,
9010                                             )?;
9011                                             let expr3_0 =
9012                                                 constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
9013                                             let expr4_0 = C::output(ctx, expr3_0);
9014                                             return Some(expr4_0);
9015                                         }
9016                                         &FloatCC::NotEqual => {
9017                                             // Rule at src/isa/x64/lower.isle line 1749.
9018                                             let expr0_0 = constructor_x64_ucomis(
9019                                                 ctx,
9020                                                 pattern11_0,
9021                                                 pattern11_1,
9022                                             )?;
9023                                             let expr1_0 = CC::NZ;
9024                                             let expr2_0 = CC::P;
9025                                             let expr3_0 = constructor_cmove_or_from_values(
9026                                                 ctx, pattern2_0, &expr1_0, &expr2_0, pattern6_1,
9027                                                 pattern6_2,
9028                                             )?;
9029                                             let expr4_0 =
9030                                                 constructor_with_flags(ctx, &expr0_0, &expr3_0)?;
9031                                             let expr5_0 = C::output(ctx, expr4_0);
9032                                             return Some(expr5_0);
9033                                         }
9034                                         &FloatCC::Ordered => {
9035                                             // Rule at src/isa/x64/lower.isle line 1692.
9036                                             let expr0_0 = constructor_x64_ucomis(
9037                                                 ctx,
9038                                                 pattern11_1,
9039                                                 pattern11_0,
9040                                             )?;
9041                                             let expr1_0 = CC::NP;
9042                                             let expr2_0 = constructor_cmove_from_values(
9043                                                 ctx, pattern2_0, &expr1_0, pattern6_1, pattern6_2,
9044                                             )?;
9045                                             let expr3_0 =
9046                                                 constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
9047                                             let expr4_0 = C::output(ctx, expr3_0);
9048                                             return Some(expr4_0);
9049                                         }
9050                                         &FloatCC::Unordered => {
9051                                             // Rule at src/isa/x64/lower.isle line 1695.
9052                                             let expr0_0 = constructor_x64_ucomis(
9053                                                 ctx,
9054                                                 pattern11_1,
9055                                                 pattern11_0,
9056                                             )?;
9057                                             let expr1_0 = CC::P;
9058                                             let expr2_0 = constructor_cmove_from_values(
9059                                                 ctx, pattern2_0, &expr1_0, pattern6_1, pattern6_2,
9060                                             )?;
9061                                             let expr3_0 =
9062                                                 constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
9063                                             let expr4_0 = C::output(ctx, expr3_0);
9064                                             return Some(expr4_0);
9065                                         }
9066                                         &FloatCC::UnorderedOrGreaterThan => {
9067                                             // Rule at src/isa/x64/lower.isle line 1727.
9068                                             let expr0_0 = constructor_x64_ucomis(
9069                                                 ctx,
9070                                                 pattern11_0,
9071                                                 pattern11_1,
9072                                             )?;
9073                                             let expr1_0 = CC::B;
9074                                             let expr2_0 = constructor_cmove_from_values(
9075                                                 ctx, pattern2_0, &expr1_0, pattern6_1, pattern6_2,
9076                                             )?;
9077                                             let expr3_0 =
9078                                                 constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
9079                                             let expr4_0 = C::output(ctx, expr3_0);
9080                                             return Some(expr4_0);
9081                                         }
9082                                         &FloatCC::UnorderedOrGreaterThanOrEqual => {
9083                                             // Rule at src/isa/x64/lower.isle line 1730.
9084                                             let expr0_0 = constructor_x64_ucomis(
9085                                                 ctx,
9086                                                 pattern11_0,
9087                                                 pattern11_1,
9088                                             )?;
9089                                             let expr1_0 = CC::BE;
9090                                             let expr2_0 = constructor_cmove_from_values(
9091                                                 ctx, pattern2_0, &expr1_0, pattern6_1, pattern6_2,
9092                                             )?;
9093                                             let expr3_0 =
9094                                                 constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
9095                                             let expr4_0 = C::output(ctx, expr3_0);
9096                                             return Some(expr4_0);
9097                                         }
9098                                         &FloatCC::UnorderedOrLessThan => {
9099                                             // Rule at src/isa/x64/lower.isle line 1704.
9100                                             let expr0_0 = constructor_x64_ucomis(
9101                                                 ctx,
9102                                                 pattern11_1,
9103                                                 pattern11_0,
9104                                             )?;
9105                                             let expr1_0 = CC::B;
9106                                             let expr2_0 = constructor_cmove_from_values(
9107                                                 ctx, pattern2_0, &expr1_0, pattern6_1, pattern6_2,
9108                                             )?;
9109                                             let expr3_0 =
9110                                                 constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
9111                                             let expr4_0 = C::output(ctx, expr3_0);
9112                                             return Some(expr4_0);
9113                                         }
9114                                         &FloatCC::UnorderedOrLessThanOrEqual => {
9115                                             // Rule at src/isa/x64/lower.isle line 1707.
9116                                             let expr0_0 = constructor_x64_ucomis(
9117                                                 ctx,
9118                                                 pattern11_1,
9119                                                 pattern11_0,
9120                                             )?;
9121                                             let expr1_0 = CC::BE;
9122                                             let expr2_0 = constructor_cmove_from_values(
9123                                                 ctx, pattern2_0, &expr1_0, pattern6_1, pattern6_2,
9124                                             )?;
9125                                             let expr3_0 =
9126                                                 constructor_with_flags(ctx, &expr0_0, &expr2_0)?;
9127                                             let expr4_0 = C::output(ctx, expr3_0);
9128                                             return Some(expr4_0);
9129                                         }
9130                                         _ => {}
9131                                     }
9132                                 }
9133                             }
9134                             &InstructionData::IntCompare {
9135                                 opcode: ref pattern9_0,
9136                                 args: ref pattern9_1,
9137                                 cond: ref pattern9_2,
9138                             } => {
9139                                 if let &Opcode::Icmp = pattern9_0 {
9140                                     let (pattern11_0, pattern11_1) =
9141                                         C::unpack_value_array_2(ctx, pattern9_1);
9142                                     let pattern12_0 = C::value_type(ctx, pattern11_0);
9143                                     if let Some(pattern13_0) = C::fits_in_64(ctx, pattern12_0) {
9144                                         // Rule at src/isa/x64/lower.isle line 1757.
9145                                         let expr0_0 = C::raw_operand_size_of_type(ctx, pattern13_0);
9146                                         let expr1_0 =
9147                                             constructor_put_in_gpr_mem_imm(ctx, pattern11_1)?;
9148                                         let expr2_0 = constructor_put_in_gpr(ctx, pattern11_0)?;
9149                                         let expr3_0 =
9150                                             constructor_x64_cmp(ctx, &expr0_0, &expr1_0, expr2_0)?;
9151                                         let expr4_0 = C::intcc_to_cc(ctx, pattern9_2);
9152                                         let expr5_0 = constructor_cmove_from_values(
9153                                             ctx, pattern2_0, &expr4_0, pattern6_1, pattern6_2,
9154                                         )?;
9155                                         let expr6_0 =
9156                                             constructor_with_flags(ctx, &expr3_0, &expr5_0)?;
9157                                         let expr7_0 = C::output(ctx, expr6_0);
9158                                         return Some(expr7_0);
9159                                     }
9160                                 }
9161                             }
9162                             _ => {}
9163                         }
9164                     }
9165                     let pattern7_0 = C::value_type(ctx, pattern6_0);
9166                     if pattern7_0 == B1 {
9167                         // Rule at src/isa/x64/lower.isle line 1764.
9168                         let expr0_0: Type = B1;
9169                         let expr1_0 = C::raw_operand_size_of_type(ctx, expr0_0);
9170                         let expr2_0 = constructor_put_in_gpr(ctx, pattern6_0)?;
9171                         let expr3_0: u32 = 1;
9172                         let expr4_0 = RegMemImm::Imm { simm32: expr3_0 };
9173                         let expr5_0 = C::gpr_mem_imm_new(ctx, &expr4_0);
9174                         let expr6_0 = constructor_x64_test(ctx, &expr1_0, &expr5_0, expr2_0)?;
9175                         let expr7_0 = CC::NZ;
9176                         let expr8_0 = constructor_cmove_from_values(
9177                             ctx, pattern2_0, &expr7_0, pattern6_1, pattern6_2,
9178                         )?;
9179                         let expr9_0 = constructor_with_flags(ctx, &expr6_0, &expr8_0)?;
9180                         let expr10_0 = C::output(ctx, expr9_0);
9181                         return Some(expr10_0);
9182                     }
9183                     if let Some(pattern8_0) = C::fits_in_64(ctx, pattern7_0) {
9184                         // Rule at src/isa/x64/lower.isle line 1771.
9185                         let expr0_0 = C::raw_operand_size_of_type(ctx, pattern8_0);
9186                         let expr1_0 = constructor_put_in_gpr(ctx, pattern6_0)?;
9187                         let expr2_0 = C::gpr_to_gpr_mem_imm(ctx, expr1_0);
9188                         let expr3_0 = constructor_x64_test(ctx, &expr0_0, &expr2_0, expr1_0)?;
9189                         let expr4_0 = CC::NZ;
9190                         let expr5_0 = constructor_cmove_from_values(
9191                             ctx, pattern2_0, &expr4_0, pattern6_1, pattern6_2,
9192                         )?;
9193                         let expr6_0 = constructor_with_flags(ctx, &expr3_0, &expr5_0)?;
9194                         let expr7_0 = C::output(ctx, expr6_0);
9195                         return Some(expr7_0);
9196                     }
9197                 }
9198             }
9199             &InstructionData::Unary {
9200                 opcode: ref pattern4_0,
9201                 arg: pattern4_1,
9202             } => {
9203                 match pattern4_0 {
9204                     &Opcode::Breduce => {
9205                         let pattern6_0 = C::value_type(ctx, pattern4_1);
9206                         if pattern6_0 == pattern2_0 {
9207                             // Rule at src/isa/x64/lower.isle line 2232.
9208                             let expr0_0 = constructor_output_value(ctx, pattern4_1)?;
9209                             return Some(expr0_0);
9210                         }
9211                     }
9212                     &Opcode::Bextend => {
9213                         let pattern6_0 = C::value_type(ctx, pattern4_1);
9214                         // Rule at src/isa/x64/lower.isle line 2213.
9215                         let expr0_0 =
9216                             constructor_generic_sextend(ctx, pattern4_1, pattern6_0, pattern2_0)?;
9217                         return Some(expr0_0);
9218                     }
9219                     &Opcode::Ireduce => {
9220                         let pattern6_0 = C::value_type(ctx, pattern4_1);
9221                         if pattern6_0 == pattern2_0 {
9222                             // Rule at src/isa/x64/lower.isle line 2221.
9223                             let expr0_0 = constructor_output_value(ctx, pattern4_1)?;
9224                             return Some(expr0_0);
9225                         }
9226                     }
9227                     &Opcode::Uextend => {
9228                         let pattern6_0 = C::value_type(ctx, pattern4_1);
9229                         if pattern6_0 == pattern2_0 {
9230                             // Rule at src/isa/x64/lower.isle line 2114.
9231                             let expr0_0 = constructor_output_value(ctx, pattern4_1)?;
9232                             return Some(expr0_0);
9233                         }
9234                     }
9235                     &Opcode::Sextend => {
9236                         let pattern6_0 = C::value_type(ctx, pattern4_1);
9237                         // Rule at src/isa/x64/lower.isle line 2207.
9238                         let expr0_0 =
9239                             constructor_generic_sextend(ctx, pattern4_1, pattern6_0, pattern2_0)?;
9240                         return Some(expr0_0);
9241                     }
9242                     _ => {}
9243                 }
9244             }
9245             _ => {}
9246         }
9247         if let Some(()) = C::avx512vl_enabled(ctx, pattern2_0) {
9248             if let Some(()) = C::avx512dq_enabled(ctx, pattern2_0) {
9249                 if let Some((pattern5_0, pattern5_1)) = C::multi_lane(ctx, pattern2_0) {
9250                     if pattern5_0 == 64 {
9251                         if pattern5_1 == 2 {
9252                             let pattern8_0 = C::inst_data(ctx, pattern0_0);
9253                             if let &InstructionData::Binary {
9254                                 opcode: ref pattern9_0,
9255                                 args: ref pattern9_1,
9256                             } = &pattern8_0
9257                             {
9258                                 if let &Opcode::Imul = pattern9_0 {
9259                                     let (pattern11_0, pattern11_1) =
9260                                         C::unpack_value_array_2(ctx, pattern9_1);
9261                                     // Rule at src/isa/x64/lower.isle line 992.
9262                                     let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern11_0)?;
9263                                     let expr1_0 = constructor_put_in_xmm(ctx, pattern11_1)?;
9264                                     let expr2_0 = constructor_x64_vpmullq(ctx, &expr0_0, expr1_0)?;
9265                                     let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
9266                                     return Some(expr3_0);
9267                                 }
9268                             }
9269                         }
9270                     }
9271                 }
9272             }
9273             if let Some(()) = C::avx512f_enabled(ctx, pattern2_0) {
9274                 if pattern2_0 == I64X2 {
9275                     let pattern6_0 = C::inst_data(ctx, pattern0_0);
9276                     if let &InstructionData::Unary {
9277                         opcode: ref pattern7_0,
9278                         arg: pattern7_1,
9279                     } = &pattern6_0
9280                     {
9281                         if let &Opcode::Iabs = pattern7_0 {
9282                             // Rule at src/isa/x64/lower.isle line 1220.
9283                             let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
9284                             let expr1_0 = constructor_x64_vpabsq(ctx, &expr0_0)?;
9285                             let expr2_0 = constructor_output_xmm(ctx, expr1_0)?;
9286                             return Some(expr2_0);
9287                         }
9288                     }
9289                 }
9290             }
9291         }
9292         if let Some((pattern3_0, pattern3_1)) = C::multi_lane(ctx, pattern2_0) {
9293             if pattern3_0 == 8 {
9294                 if pattern3_1 == 16 {
9295                     let pattern6_0 = C::inst_data(ctx, pattern0_0);
9296                     if let &InstructionData::Binary {
9297                         opcode: ref pattern7_0,
9298                         args: ref pattern7_1,
9299                     } = &pattern6_0
9300                     {
9301                         match pattern7_0 {
9302                             &Opcode::AvgRound => {
9303                                 let (pattern9_0, pattern9_1) =
9304                                     C::unpack_value_array_2(ctx, pattern7_1);
9305                                 // Rule at src/isa/x64/lower.isle line 903.
9306                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
9307                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
9308                                 let expr2_0 = constructor_x64_pavgb(ctx, expr0_0, &expr1_0)?;
9309                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
9310                                 return Some(expr3_0);
9311                             }
9312                             &Opcode::UaddSat => {
9313                                 let (pattern9_0, pattern9_1) =
9314                                     C::unpack_value_array_2(ctx, pattern7_1);
9315                                 // Rule at src/isa/x64/lower.isle line 136.
9316                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
9317                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
9318                                 let expr2_0 = constructor_x64_paddusb(ctx, expr0_0, &expr1_0)?;
9319                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
9320                                 return Some(expr3_0);
9321                             }
9322                             &Opcode::SaddSat => {
9323                                 let (pattern9_0, pattern9_1) =
9324                                     C::unpack_value_array_2(ctx, pattern7_1);
9325                                 // Rule at src/isa/x64/lower.isle line 126.
9326                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
9327                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
9328                                 let expr2_0 = constructor_x64_paddsb(ctx, expr0_0, &expr1_0)?;
9329                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
9330                                 return Some(expr3_0);
9331                             }
9332                             &Opcode::UsubSat => {
9333                                 let (pattern9_0, pattern9_1) =
9334                                     C::unpack_value_array_2(ctx, pattern7_1);
9335                                 // Rule at src/isa/x64/lower.isle line 282.
9336                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
9337                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
9338                                 let expr2_0 = constructor_x64_psubusb(ctx, expr0_0, &expr1_0)?;
9339                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
9340                                 return Some(expr3_0);
9341                             }
9342                             &Opcode::SsubSat => {
9343                                 let (pattern9_0, pattern9_1) =
9344                                     C::unpack_value_array_2(ctx, pattern7_1);
9345                                 // Rule at src/isa/x64/lower.isle line 272.
9346                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
9347                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
9348                                 let expr2_0 = constructor_x64_psubsb(ctx, expr0_0, &expr1_0)?;
9349                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
9350                                 return Some(expr3_0);
9351                             }
9352                             &Opcode::Iadd => {
9353                                 let (pattern9_0, pattern9_1) =
9354                                     C::unpack_value_array_2(ctx, pattern7_1);
9355                                 // Rule at src/isa/x64/lower.isle line 94.
9356                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
9357                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
9358                                 let expr2_0 = constructor_x64_paddb(ctx, expr0_0, &expr1_0)?;
9359                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
9360                                 return Some(expr3_0);
9361                             }
9362                             &Opcode::Isub => {
9363                                 let (pattern9_0, pattern9_1) =
9364                                     C::unpack_value_array_2(ctx, pattern7_1);
9365                                 // Rule at src/isa/x64/lower.isle line 240.
9366                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
9367                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
9368                                 let expr2_0 = constructor_x64_psubb(ctx, expr0_0, &expr1_0)?;
9369                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
9370                                 return Some(expr3_0);
9371                             }
9372                             _ => {}
9373                         }
9374                     }
9375                 }
9376             }
9377             if pattern3_0 == 16 {
9378                 if pattern3_1 == 8 {
9379                     let pattern6_0 = C::inst_data(ctx, pattern0_0);
9380                     if let &InstructionData::Binary {
9381                         opcode: ref pattern7_0,
9382                         args: ref pattern7_1,
9383                     } = &pattern6_0
9384                     {
9385                         match pattern7_0 {
9386                             &Opcode::AvgRound => {
9387                                 let (pattern9_0, pattern9_1) =
9388                                     C::unpack_value_array_2(ctx, pattern7_1);
9389                                 // Rule at src/isa/x64/lower.isle line 907.
9390                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
9391                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
9392                                 let expr2_0 = constructor_x64_pavgw(ctx, expr0_0, &expr1_0)?;
9393                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
9394                                 return Some(expr3_0);
9395                             }
9396                             &Opcode::UaddSat => {
9397                                 let (pattern9_0, pattern9_1) =
9398                                     C::unpack_value_array_2(ctx, pattern7_1);
9399                                 // Rule at src/isa/x64/lower.isle line 140.
9400                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
9401                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
9402                                 let expr2_0 = constructor_x64_paddusw(ctx, expr0_0, &expr1_0)?;
9403                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
9404                                 return Some(expr3_0);
9405                             }
9406                             &Opcode::SaddSat => {
9407                                 let (pattern9_0, pattern9_1) =
9408                                     C::unpack_value_array_2(ctx, pattern7_1);
9409                                 // Rule at src/isa/x64/lower.isle line 130.
9410                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
9411                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
9412                                 let expr2_0 = constructor_x64_paddsw(ctx, expr0_0, &expr1_0)?;
9413                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
9414                                 return Some(expr3_0);
9415                             }
9416                             &Opcode::UsubSat => {
9417                                 let (pattern9_0, pattern9_1) =
9418                                     C::unpack_value_array_2(ctx, pattern7_1);
9419                                 // Rule at src/isa/x64/lower.isle line 286.
9420                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
9421                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
9422                                 let expr2_0 = constructor_x64_psubusw(ctx, expr0_0, &expr1_0)?;
9423                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
9424                                 return Some(expr3_0);
9425                             }
9426                             &Opcode::SsubSat => {
9427                                 let (pattern9_0, pattern9_1) =
9428                                     C::unpack_value_array_2(ctx, pattern7_1);
9429                                 // Rule at src/isa/x64/lower.isle line 276.
9430                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
9431                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
9432                                 let expr2_0 = constructor_x64_psubsw(ctx, expr0_0, &expr1_0)?;
9433                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
9434                                 return Some(expr3_0);
9435                             }
9436                             &Opcode::Iadd => {
9437                                 let (pattern9_0, pattern9_1) =
9438                                     C::unpack_value_array_2(ctx, pattern7_1);
9439                                 // Rule at src/isa/x64/lower.isle line 98.
9440                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
9441                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
9442                                 let expr2_0 = constructor_x64_paddw(ctx, expr0_0, &expr1_0)?;
9443                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
9444                                 return Some(expr3_0);
9445                             }
9446                             &Opcode::Isub => {
9447                                 let (pattern9_0, pattern9_1) =
9448                                     C::unpack_value_array_2(ctx, pattern7_1);
9449                                 // Rule at src/isa/x64/lower.isle line 244.
9450                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
9451                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
9452                                 let expr2_0 = constructor_x64_psubw(ctx, expr0_0, &expr1_0)?;
9453                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
9454                                 return Some(expr3_0);
9455                             }
9456                             &Opcode::Imul => {
9457                                 let (pattern9_0, pattern9_1) =
9458                                     C::unpack_value_array_2(ctx, pattern7_1);
9459                                 if let Some(pattern10_0) = C::def_inst(ctx, pattern9_0) {
9460                                     let pattern11_0 = C::inst_data(ctx, pattern10_0);
9461                                     if let &InstructionData::Unary {
9462                                         opcode: ref pattern12_0,
9463                                         arg: pattern12_1,
9464                                     } = &pattern11_0
9465                                     {
9466                                         match pattern12_0 {
9467                                             &Opcode::SwidenLow => {
9468                                                 let pattern14_0 = C::value_type(ctx, pattern12_1);
9469                                                 if let Some((pattern15_0, pattern15_1)) =
9470                                                     C::multi_lane(ctx, pattern14_0)
9471                                                 {
9472                                                     if pattern15_0 == 8 {
9473                                                         if pattern15_1 == 16 {
9474                                                             if let Some(pattern18_0) =
9475                                                                 C::def_inst(ctx, pattern9_1)
9476                                                             {
9477                                                                 let pattern19_0 =
9478                                                                     C::inst_data(ctx, pattern18_0);
9479                                                                 if let &InstructionData::Unary {
9480                                                                     opcode: ref pattern20_0,
9481                                                                     arg: pattern20_1,
9482                                                                 } = &pattern19_0
9483                                                                 {
9484                                                                     if let &Opcode::SwidenLow =
9485                                                                         pattern20_0
9486                                                                     {
9487                                                                         let pattern22_0 =
9488                                                                             C::value_type(
9489                                                                                 ctx,
9490                                                                                 pattern20_1,
9491                                                                             );
9492                                                                         if let Some((
9493                                                                             pattern23_0,
9494                                                                             pattern23_1,
9495                                                                         )) = C::multi_lane(
9496                                                                             ctx,
9497                                                                             pattern22_0,
9498                                                                         ) {
9499                                                                             if pattern23_0 == 8 {
9500                                                                                 if pattern23_1 == 16
9501                                                                                 {
9502                                                                                     // Rule at src/isa/x64/lower.isle line 1080.
9503                                                                                     let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern12_1)?;
9504                                                                                     let expr1_0 = constructor_x64_pmovsxbw(ctx, &expr0_0)?;
9505                                                                                     let expr2_0 = constructor_put_in_xmm_mem(ctx, pattern20_1)?;
9506                                                                                     let expr3_0 = constructor_x64_pmovsxbw(ctx, &expr2_0)?;
9507                                                                                     let expr4_0 = C::xmm_to_xmm_mem(ctx, expr3_0);
9508                                                                                     let expr5_0 = constructor_x64_pmullw(ctx, expr1_0, &expr4_0)?;
9509                                                                                     let expr6_0 = constructor_output_xmm(ctx, expr5_0)?;
9510                                                                                     return Some(
9511                                                                                         expr6_0,
9512                                                                                     );
9513                                                                                 }
9514                                                                             }
9515                                                                         }
9516                                                                     }
9517                                                                 }
9518                                                             }
9519                                                         }
9520                                                     }
9521                                                 }
9522                                             }
9523                                             &Opcode::SwidenHigh => {
9524                                                 let pattern14_0 = C::value_type(ctx, pattern12_1);
9525                                                 if let Some((pattern15_0, pattern15_1)) =
9526                                                     C::multi_lane(ctx, pattern14_0)
9527                                                 {
9528                                                     if pattern15_0 == 8 {
9529                                                         if pattern15_1 == 16 {
9530                                                             if let Some(pattern18_0) =
9531                                                                 C::def_inst(ctx, pattern9_1)
9532                                                             {
9533                                                                 let pattern19_0 =
9534                                                                     C::inst_data(ctx, pattern18_0);
9535                                                                 if let &InstructionData::Unary {
9536                                                                     opcode: ref pattern20_0,
9537                                                                     arg: pattern20_1,
9538                                                                 } = &pattern19_0
9539                                                                 {
9540                                                                     if let &Opcode::SwidenHigh =
9541                                                                         pattern20_0
9542                                                                     {
9543                                                                         let pattern22_0 =
9544                                                                             C::value_type(
9545                                                                                 ctx,
9546                                                                                 pattern20_1,
9547                                                                             );
9548                                                                         if let Some((
9549                                                                             pattern23_0,
9550                                                                             pattern23_1,
9551                                                                         )) = C::multi_lane(
9552                                                                             ctx,
9553                                                                             pattern22_0,
9554                                                                         ) {
9555                                                                             if pattern23_0 == 8 {
9556                                                                                 if pattern23_1 == 16
9557                                                                                 {
9558                                                                                     // Rule at src/isa/x64/lower.isle line 1040.
9559                                                                                     let expr0_0 = constructor_put_in_xmm(ctx, pattern12_1)?;
9560                                                                                     let expr1_0 = C::xmm_to_xmm_mem(ctx, expr0_0);
9561                                                                                     let expr2_0: u8 = 8;
9562                                                                                     let expr3_0 = OperandSize::Size32;
9563                                                                                     let expr4_0 = constructor_x64_palignr(ctx, expr0_0, &expr1_0, expr2_0, &expr3_0)?;
9564                                                                                     let expr5_0 = C::xmm_to_xmm_mem(ctx, expr4_0);
9565                                                                                     let expr6_0 = constructor_x64_pmovsxbw(ctx, &expr5_0)?;
9566                                                                                     let expr7_0 = constructor_put_in_xmm(ctx, pattern20_1)?;
9567                                                                                     let expr8_0 = C::xmm_to_xmm_mem(ctx, expr7_0);
9568                                                                                     let expr9_0: u8 = 8;
9569                                                                                     let expr10_0 = OperandSize::Size32;
9570                                                                                     let expr11_0 = constructor_x64_palignr(ctx, expr7_0, &expr8_0, expr9_0, &expr10_0)?;
9571                                                                                     let expr12_0 = C::xmm_to_xmm_mem(ctx, expr11_0);
9572                                                                                     let expr13_0 = constructor_x64_pmovsxbw(ctx, &expr12_0)?;
9573                                                                                     let expr14_0 = C::xmm_to_xmm_mem(ctx, expr13_0);
9574                                                                                     let expr15_0 = constructor_x64_pmullw(ctx, expr6_0, &expr14_0)?;
9575                                                                                     let expr16_0 = constructor_output_xmm(ctx, expr15_0)?;
9576                                                                                     return Some(
9577                                                                                         expr16_0,
9578                                                                                     );
9579                                                                                 }
9580                                                                             }
9581                                                                         }
9582                                                                     }
9583                                                                 }
9584                                                             }
9585                                                         }
9586                                                     }
9587                                                 }
9588                                             }
9589                                             &Opcode::UwidenLow => {
9590                                                 let pattern14_0 = C::value_type(ctx, pattern12_1);
9591                                                 if let Some((pattern15_0, pattern15_1)) =
9592                                                     C::multi_lane(ctx, pattern14_0)
9593                                                 {
9594                                                     if pattern15_0 == 8 {
9595                                                         if pattern15_1 == 16 {
9596                                                             if let Some(pattern18_0) =
9597                                                                 C::def_inst(ctx, pattern9_1)
9598                                                             {
9599                                                                 let pattern19_0 =
9600                                                                     C::inst_data(ctx, pattern18_0);
9601                                                                 if let &InstructionData::Unary {
9602                                                                     opcode: ref pattern20_0,
9603                                                                     arg: pattern20_1,
9604                                                                 } = &pattern19_0
9605                                                                 {
9606                                                                     if let &Opcode::UwidenLow =
9607                                                                         pattern20_0
9608                                                                     {
9609                                                                         let pattern22_0 =
9610                                                                             C::value_type(
9611                                                                                 ctx,
9612                                                                                 pattern20_1,
9613                                                                             );
9614                                                                         if let Some((
9615                                                                             pattern23_0,
9616                                                                             pattern23_1,
9617                                                                         )) = C::multi_lane(
9618                                                                             ctx,
9619                                                                             pattern22_0,
9620                                                                         ) {
9621                                                                             if pattern23_0 == 8 {
9622                                                                                 if pattern23_1 == 16
9623                                                                                 {
9624                                                                                     // Rule at src/isa/x64/lower.isle line 1156.
9625                                                                                     let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern12_1)?;
9626                                                                                     let expr1_0 = constructor_x64_pmovzxbw(ctx, &expr0_0)?;
9627                                                                                     let expr2_0 = constructor_put_in_xmm_mem(ctx, pattern20_1)?;
9628                                                                                     let expr3_0 = constructor_x64_pmovzxbw(ctx, &expr2_0)?;
9629                                                                                     let expr4_0 = C::xmm_to_xmm_mem(ctx, expr3_0);
9630                                                                                     let expr5_0 = constructor_x64_pmullw(ctx, expr1_0, &expr4_0)?;
9631                                                                                     let expr6_0 = constructor_output_xmm(ctx, expr5_0)?;
9632                                                                                     return Some(
9633                                                                                         expr6_0,
9634                                                                                     );
9635                                                                                 }
9636                                                                             }
9637                                                                         }
9638                                                                     }
9639                                                                 }
9640                                                             }
9641                                                         }
9642                                                     }
9643                                                 }
9644                                             }
9645                                             &Opcode::UwidenHigh => {
9646                                                 let pattern14_0 = C::value_type(ctx, pattern12_1);
9647                                                 if let Some((pattern15_0, pattern15_1)) =
9648                                                     C::multi_lane(ctx, pattern14_0)
9649                                                 {
9650                                                     if pattern15_0 == 8 {
9651                                                         if pattern15_1 == 16 {
9652                                                             if let Some(pattern18_0) =
9653                                                                 C::def_inst(ctx, pattern9_1)
9654                                                             {
9655                                                                 let pattern19_0 =
9656                                                                     C::inst_data(ctx, pattern18_0);
9657                                                                 if let &InstructionData::Unary {
9658                                                                     opcode: ref pattern20_0,
9659                                                                     arg: pattern20_1,
9660                                                                 } = &pattern19_0
9661                                                                 {
9662                                                                     if let &Opcode::UwidenHigh =
9663                                                                         pattern20_0
9664                                                                     {
9665                                                                         let pattern22_0 =
9666                                                                             C::value_type(
9667                                                                                 ctx,
9668                                                                                 pattern20_1,
9669                                                                             );
9670                                                                         if let Some((
9671                                                                             pattern23_0,
9672                                                                             pattern23_1,
9673                                                                         )) = C::multi_lane(
9674                                                                             ctx,
9675                                                                             pattern22_0,
9676                                                                         ) {
9677                                                                             if pattern23_0 == 8 {
9678                                                                                 if pattern23_1 == 16
9679                                                                                 {
9680                                                                                     // Rule at src/isa/x64/lower.isle line 1116.
9681                                                                                     let expr0_0 = constructor_put_in_xmm(ctx, pattern12_1)?;
9682                                                                                     let expr1_0 = C::xmm_to_xmm_mem(ctx, expr0_0);
9683                                                                                     let expr2_0: u8 = 8;
9684                                                                                     let expr3_0 = OperandSize::Size32;
9685                                                                                     let expr4_0 = constructor_x64_palignr(ctx, expr0_0, &expr1_0, expr2_0, &expr3_0)?;
9686                                                                                     let expr5_0 = C::xmm_to_xmm_mem(ctx, expr4_0);
9687                                                                                     let expr6_0 = constructor_x64_pmovzxbw(ctx, &expr5_0)?;
9688                                                                                     let expr7_0 = constructor_put_in_xmm(ctx, pattern20_1)?;
9689                                                                                     let expr8_0 = C::xmm_to_xmm_mem(ctx, expr7_0);
9690                                                                                     let expr9_0: u8 = 8;
9691                                                                                     let expr10_0 = OperandSize::Size32;
9692                                                                                     let expr11_0 = constructor_x64_palignr(ctx, expr7_0, &expr8_0, expr9_0, &expr10_0)?;
9693                                                                                     let expr12_0 = C::xmm_to_xmm_mem(ctx, expr11_0);
9694                                                                                     let expr13_0 = constructor_x64_pmovzxbw(ctx, &expr12_0)?;
9695                                                                                     let expr14_0 = C::xmm_to_xmm_mem(ctx, expr13_0);
9696                                                                                     let expr15_0 = constructor_x64_pmullw(ctx, expr6_0, &expr14_0)?;
9697                                                                                     let expr16_0 = constructor_output_xmm(ctx, expr15_0)?;
9698                                                                                     return Some(
9699                                                                                         expr16_0,
9700                                                                                     );
9701                                                                                 }
9702                                                                             }
9703                                                                         }
9704                                                                     }
9705                                                                 }
9706                                                             }
9707                                                         }
9708                                                     }
9709                                                 }
9710                                             }
9711                                             _ => {}
9712                                         }
9713                                     }
9714                                 }
9715                                 // Rule at src/isa/x64/lower.isle line 984.
9716                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
9717                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
9718                                 let expr2_0 = constructor_x64_pmullw(ctx, expr0_0, &expr1_0)?;
9719                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
9720                                 return Some(expr3_0);
9721                             }
9722                             _ => {}
9723                         }
9724                     }
9725                 }
9726             }
9727             if pattern3_0 == 32 {
9728                 if pattern3_1 == 4 {
9729                     let pattern6_0 = C::inst_data(ctx, pattern0_0);
9730                     if let &InstructionData::Binary {
9731                         opcode: ref pattern7_0,
9732                         args: ref pattern7_1,
9733                     } = &pattern6_0
9734                     {
9735                         match pattern7_0 {
9736                             &Opcode::Iadd => {
9737                                 let (pattern9_0, pattern9_1) =
9738                                     C::unpack_value_array_2(ctx, pattern7_1);
9739                                 // Rule at src/isa/x64/lower.isle line 102.
9740                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
9741                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
9742                                 let expr2_0 = constructor_x64_paddd(ctx, expr0_0, &expr1_0)?;
9743                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
9744                                 return Some(expr3_0);
9745                             }
9746                             &Opcode::Isub => {
9747                                 let (pattern9_0, pattern9_1) =
9748                                     C::unpack_value_array_2(ctx, pattern7_1);
9749                                 // Rule at src/isa/x64/lower.isle line 248.
9750                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
9751                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
9752                                 let expr2_0 = constructor_x64_psubd(ctx, expr0_0, &expr1_0)?;
9753                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
9754                                 return Some(expr3_0);
9755                             }
9756                             &Opcode::Imul => {
9757                                 let (pattern9_0, pattern9_1) =
9758                                     C::unpack_value_array_2(ctx, pattern7_1);
9759                                 if let Some(pattern10_0) = C::def_inst(ctx, pattern9_0) {
9760                                     let pattern11_0 = C::inst_data(ctx, pattern10_0);
9761                                     if let &InstructionData::Unary {
9762                                         opcode: ref pattern12_0,
9763                                         arg: pattern12_1,
9764                                     } = &pattern11_0
9765                                     {
9766                                         match pattern12_0 {
9767                                             &Opcode::SwidenLow => {
9768                                                 let pattern14_0 = C::value_type(ctx, pattern12_1);
9769                                                 if let Some((pattern15_0, pattern15_1)) =
9770                                                     C::multi_lane(ctx, pattern14_0)
9771                                                 {
9772                                                     if pattern15_0 == 16 {
9773                                                         if pattern15_1 == 8 {
9774                                                             if let Some(pattern18_0) =
9775                                                                 C::def_inst(ctx, pattern9_1)
9776                                                             {
9777                                                                 let pattern19_0 =
9778                                                                     C::inst_data(ctx, pattern18_0);
9779                                                                 if let &InstructionData::Unary {
9780                                                                     opcode: ref pattern20_0,
9781                                                                     arg: pattern20_1,
9782                                                                 } = &pattern19_0
9783                                                                 {
9784                                                                     if let &Opcode::SwidenLow =
9785                                                                         pattern20_0
9786                                                                     {
9787                                                                         let pattern22_0 =
9788                                                                             C::value_type(
9789                                                                                 ctx,
9790                                                                                 pattern20_1,
9791                                                                             );
9792                                                                         if let Some((
9793                                                                             pattern23_0,
9794                                                                             pattern23_1,
9795                                                                         )) = C::multi_lane(
9796                                                                             ctx,
9797                                                                             pattern22_0,
9798                                                                         ) {
9799                                                                             if pattern23_0 == 16 {
9800                                                                                 if pattern23_1 == 8
9801                                                                                 {
9802                                                                                     // Rule at src/isa/x64/lower.isle line 1090.
9803                                                                                     let expr0_0 = constructor_put_in_xmm(ctx, pattern12_1)?;
9804                                                                                     let expr1_0 = constructor_put_in_xmm(ctx, pattern20_1)?;
9805                                                                                     let expr2_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
9806                                                                                     let expr3_0 = constructor_x64_pmullw(ctx, expr0_0, &expr2_0)?;
9807                                                                                     let expr4_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
9808                                                                                     let expr5_0 = constructor_x64_pmulhw(ctx, expr0_0, &expr4_0)?;
9809                                                                                     let expr6_0 = C::xmm_to_xmm_mem(ctx, expr5_0);
9810                                                                                     let expr7_0 = constructor_x64_punpcklwd(ctx, expr3_0, &expr6_0)?;
9811                                                                                     let expr8_0 = constructor_output_xmm(ctx, expr7_0)?;
9812                                                                                     return Some(
9813                                                                                         expr8_0,
9814                                                                                     );
9815                                                                                 }
9816                                                                             }
9817                                                                         }
9818                                                                     }
9819                                                                 }
9820                                                             }
9821                                                         }
9822                                                     }
9823                                                 }
9824                                             }
9825                                             &Opcode::SwidenHigh => {
9826                                                 let pattern14_0 = C::value_type(ctx, pattern12_1);
9827                                                 if let Some((pattern15_0, pattern15_1)) =
9828                                                     C::multi_lane(ctx, pattern14_0)
9829                                                 {
9830                                                     if pattern15_0 == 16 {
9831                                                         if pattern15_1 == 8 {
9832                                                             if let Some(pattern18_0) =
9833                                                                 C::def_inst(ctx, pattern9_1)
9834                                                             {
9835                                                                 let pattern19_0 =
9836                                                                     C::inst_data(ctx, pattern18_0);
9837                                                                 if let &InstructionData::Unary {
9838                                                                     opcode: ref pattern20_0,
9839                                                                     arg: pattern20_1,
9840                                                                 } = &pattern19_0
9841                                                                 {
9842                                                                     if let &Opcode::SwidenHigh =
9843                                                                         pattern20_0
9844                                                                     {
9845                                                                         let pattern22_0 =
9846                                                                             C::value_type(
9847                                                                                 ctx,
9848                                                                                 pattern20_1,
9849                                                                             );
9850                                                                         if let Some((
9851                                                                             pattern23_0,
9852                                                                             pattern23_1,
9853                                                                         )) = C::multi_lane(
9854                                                                             ctx,
9855                                                                             pattern22_0,
9856                                                                         ) {
9857                                                                             if pattern23_0 == 16 {
9858                                                                                 if pattern23_1 == 8
9859                                                                                 {
9860                                                                                     // Rule at src/isa/x64/lower.isle line 1054.
9861                                                                                     let expr0_0 = constructor_put_in_xmm(ctx, pattern12_1)?;
9862                                                                                     let expr1_0 = constructor_put_in_xmm(ctx, pattern20_1)?;
9863                                                                                     let expr2_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
9864                                                                                     let expr3_0 = constructor_x64_pmullw(ctx, expr0_0, &expr2_0)?;
9865                                                                                     let expr4_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
9866                                                                                     let expr5_0 = constructor_x64_pmulhw(ctx, expr0_0, &expr4_0)?;
9867                                                                                     let expr6_0 = C::xmm_to_xmm_mem(ctx, expr5_0);
9868                                                                                     let expr7_0 = constructor_x64_punpckhwd(ctx, expr3_0, &expr6_0)?;
9869                                                                                     let expr8_0 = constructor_output_xmm(ctx, expr7_0)?;
9870                                                                                     return Some(
9871                                                                                         expr8_0,
9872                                                                                     );
9873                                                                                 }
9874                                                                             }
9875                                                                         }
9876                                                                     }
9877                                                                 }
9878                                                             }
9879                                                         }
9880                                                     }
9881                                                 }
9882                                             }
9883                                             &Opcode::UwidenLow => {
9884                                                 let pattern14_0 = C::value_type(ctx, pattern12_1);
9885                                                 if let Some((pattern15_0, pattern15_1)) =
9886                                                     C::multi_lane(ctx, pattern14_0)
9887                                                 {
9888                                                     if pattern15_0 == 16 {
9889                                                         if pattern15_1 == 8 {
9890                                                             if let Some(pattern18_0) =
9891                                                                 C::def_inst(ctx, pattern9_1)
9892                                                             {
9893                                                                 let pattern19_0 =
9894                                                                     C::inst_data(ctx, pattern18_0);
9895                                                                 if let &InstructionData::Unary {
9896                                                                     opcode: ref pattern20_0,
9897                                                                     arg: pattern20_1,
9898                                                                 } = &pattern19_0
9899                                                                 {
9900                                                                     if let &Opcode::UwidenLow =
9901                                                                         pattern20_0
9902                                                                     {
9903                                                                         let pattern22_0 =
9904                                                                             C::value_type(
9905                                                                                 ctx,
9906                                                                                 pattern20_1,
9907                                                                             );
9908                                                                         if let Some((
9909                                                                             pattern23_0,
9910                                                                             pattern23_1,
9911                                                                         )) = C::multi_lane(
9912                                                                             ctx,
9913                                                                             pattern22_0,
9914                                                                         ) {
9915                                                                             if pattern23_0 == 16 {
9916                                                                                 if pattern23_1 == 8
9917                                                                                 {
9918                                                                                     // Rule at src/isa/x64/lower.isle line 1166.
9919                                                                                     let expr0_0 = constructor_put_in_xmm(ctx, pattern12_1)?;
9920                                                                                     let expr1_0 = constructor_put_in_xmm(ctx, pattern20_1)?;
9921                                                                                     let expr2_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
9922                                                                                     let expr3_0 = constructor_x64_pmullw(ctx, expr0_0, &expr2_0)?;
9923                                                                                     let expr4_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
9924                                                                                     let expr5_0 = constructor_x64_pmulhuw(ctx, expr0_0, &expr4_0)?;
9925                                                                                     let expr6_0 = C::xmm_to_xmm_mem(ctx, expr5_0);
9926                                                                                     let expr7_0 = constructor_x64_punpcklwd(ctx, expr3_0, &expr6_0)?;
9927                                                                                     let expr8_0 = constructor_output_xmm(ctx, expr7_0)?;
9928                                                                                     return Some(
9929                                                                                         expr8_0,
9930                                                                                     );
9931                                                                                 }
9932                                                                             }
9933                                                                         }
9934                                                                     }
9935                                                                 }
9936                                                             }
9937                                                         }
9938                                                     }
9939                                                 }
9940                                             }
9941                                             &Opcode::UwidenHigh => {
9942                                                 let pattern14_0 = C::value_type(ctx, pattern12_1);
9943                                                 if let Some((pattern15_0, pattern15_1)) =
9944                                                     C::multi_lane(ctx, pattern14_0)
9945                                                 {
9946                                                     if pattern15_0 == 16 {
9947                                                         if pattern15_1 == 8 {
9948                                                             if let Some(pattern18_0) =
9949                                                                 C::def_inst(ctx, pattern9_1)
9950                                                             {
9951                                                                 let pattern19_0 =
9952                                                                     C::inst_data(ctx, pattern18_0);
9953                                                                 if let &InstructionData::Unary {
9954                                                                     opcode: ref pattern20_0,
9955                                                                     arg: pattern20_1,
9956                                                                 } = &pattern19_0
9957                                                                 {
9958                                                                     if let &Opcode::UwidenHigh =
9959                                                                         pattern20_0
9960                                                                     {
9961                                                                         let pattern22_0 =
9962                                                                             C::value_type(
9963                                                                                 ctx,
9964                                                                                 pattern20_1,
9965                                                                             );
9966                                                                         if let Some((
9967                                                                             pattern23_0,
9968                                                                             pattern23_1,
9969                                                                         )) = C::multi_lane(
9970                                                                             ctx,
9971                                                                             pattern22_0,
9972                                                                         ) {
9973                                                                             if pattern23_0 == 16 {
9974                                                                                 if pattern23_1 == 8
9975                                                                                 {
9976                                                                                     // Rule at src/isa/x64/lower.isle line 1130.
9977                                                                                     let expr0_0 = constructor_put_in_xmm(ctx, pattern12_1)?;
9978                                                                                     let expr1_0 = constructor_put_in_xmm(ctx, pattern20_1)?;
9979                                                                                     let expr2_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
9980                                                                                     let expr3_0 = constructor_x64_pmullw(ctx, expr0_0, &expr2_0)?;
9981                                                                                     let expr4_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
9982                                                                                     let expr5_0 = constructor_x64_pmulhuw(ctx, expr0_0, &expr4_0)?;
9983                                                                                     let expr6_0 = C::xmm_to_xmm_mem(ctx, expr5_0);
9984                                                                                     let expr7_0 = constructor_x64_punpckhwd(ctx, expr3_0, &expr6_0)?;
9985                                                                                     let expr8_0 = constructor_output_xmm(ctx, expr7_0)?;
9986                                                                                     return Some(
9987                                                                                         expr8_0,
9988                                                                                     );
9989                                                                                 }
9990                                                                             }
9991                                                                         }
9992                                                                     }
9993                                                                 }
9994                                                             }
9995                                                         }
9996                                                     }
9997                                                 }
9998                                             }
9999                                             _ => {}
10000                                         }
10001                                     }
10002                                 }
10003                                 // Rule at src/isa/x64/lower.isle line 987.
10004                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
10005                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
10006                                 let expr2_0 = constructor_x64_pmulld(ctx, expr0_0, &expr1_0)?;
10007                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
10008                                 return Some(expr3_0);
10009                             }
10010                             _ => {}
10011                         }
10012                     }
10013                 }
10014             }
10015             if pattern3_0 == 64 {
10016                 if pattern3_1 == 2 {
10017                     let pattern6_0 = C::inst_data(ctx, pattern0_0);
10018                     if let &InstructionData::Binary {
10019                         opcode: ref pattern7_0,
10020                         args: ref pattern7_1,
10021                     } = &pattern6_0
10022                     {
10023                         match pattern7_0 {
10024                             &Opcode::Iadd => {
10025                                 let (pattern9_0, pattern9_1) =
10026                                     C::unpack_value_array_2(ctx, pattern7_1);
10027                                 // Rule at src/isa/x64/lower.isle line 106.
10028                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
10029                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
10030                                 let expr2_0 = constructor_x64_paddq(ctx, expr0_0, &expr1_0)?;
10031                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
10032                                 return Some(expr3_0);
10033                             }
10034                             &Opcode::Isub => {
10035                                 let (pattern9_0, pattern9_1) =
10036                                     C::unpack_value_array_2(ctx, pattern7_1);
10037                                 // Rule at src/isa/x64/lower.isle line 252.
10038                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
10039                                 let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern9_1)?;
10040                                 let expr2_0 = constructor_x64_psubq(ctx, expr0_0, &expr1_0)?;
10041                                 let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
10042                                 return Some(expr3_0);
10043                             }
10044                             &Opcode::Imul => {
10045                                 let (pattern9_0, pattern9_1) =
10046                                     C::unpack_value_array_2(ctx, pattern7_1);
10047                                 if let Some(pattern10_0) = C::def_inst(ctx, pattern9_0) {
10048                                     let pattern11_0 = C::inst_data(ctx, pattern10_0);
10049                                     if let &InstructionData::Unary {
10050                                         opcode: ref pattern12_0,
10051                                         arg: pattern12_1,
10052                                     } = &pattern11_0
10053                                     {
10054                                         match pattern12_0 {
10055                                             &Opcode::SwidenLow => {
10056                                                 let pattern14_0 = C::value_type(ctx, pattern12_1);
10057                                                 if let Some((pattern15_0, pattern15_1)) =
10058                                                     C::multi_lane(ctx, pattern14_0)
10059                                                 {
10060                                                     if pattern15_0 == 32 {
10061                                                         if pattern15_1 == 4 {
10062                                                             if let Some(pattern18_0) =
10063                                                                 C::def_inst(ctx, pattern9_1)
10064                                                             {
10065                                                                 let pattern19_0 =
10066                                                                     C::inst_data(ctx, pattern18_0);
10067                                                                 if let &InstructionData::Unary {
10068                                                                     opcode: ref pattern20_0,
10069                                                                     arg: pattern20_1,
10070                                                                 } = &pattern19_0
10071                                                                 {
10072                                                                     if let &Opcode::SwidenLow =
10073                                                                         pattern20_0
10074                                                                     {
10075                                                                         let pattern22_0 =
10076                                                                             C::value_type(
10077                                                                                 ctx,
10078                                                                                 pattern20_1,
10079                                                                             );
10080                                                                         if let Some((
10081                                                                             pattern23_0,
10082                                                                             pattern23_1,
10083                                                                         )) = C::multi_lane(
10084                                                                             ctx,
10085                                                                             pattern22_0,
10086                                                                         ) {
10087                                                                             if pattern23_0 == 32 {
10088                                                                                 if pattern23_1 == 4
10089                                                                                 {
10090                                                                                     // Rule at src/isa/x64/lower.isle line 1102.
10091                                                                                     let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern12_1)?;
10092                                                                                     let expr1_0: u8 = 80;
10093                                                                                     let expr2_0 = OperandSize::Size32;
10094                                                                                     let expr3_0 = constructor_x64_pshufd(ctx, &expr0_0, expr1_0, &expr2_0)?;
10095                                                                                     let expr4_0 = constructor_put_in_xmm_mem(ctx, pattern20_1)?;
10096                                                                                     let expr5_0: u8 = 80;
10097                                                                                     let expr6_0 = OperandSize::Size32;
10098                                                                                     let expr7_0 = constructor_x64_pshufd(ctx, &expr4_0, expr5_0, &expr6_0)?;
10099                                                                                     let expr8_0 = C::xmm_to_xmm_mem(ctx, expr7_0);
10100                                                                                     let expr9_0 = constructor_x64_pmuldq(ctx, expr3_0, &expr8_0)?;
10101                                                                                     let expr10_0 = constructor_output_xmm(ctx, expr9_0)?;
10102                                                                                     return Some(
10103                                                                                         expr10_0,
10104                                                                                     );
10105                                                                                 }
10106                                                                             }
10107                                                                         }
10108                                                                     }
10109                                                                 }
10110                                                             }
10111                                                         }
10112                                                     }
10113                                                 }
10114                                             }
10115                                             &Opcode::SwidenHigh => {
10116                                                 let pattern14_0 = C::value_type(ctx, pattern12_1);
10117                                                 if let Some((pattern15_0, pattern15_1)) =
10118                                                     C::multi_lane(ctx, pattern14_0)
10119                                                 {
10120                                                     if pattern15_0 == 32 {
10121                                                         if pattern15_1 == 4 {
10122                                                             if let Some(pattern18_0) =
10123                                                                 C::def_inst(ctx, pattern9_1)
10124                                                             {
10125                                                                 let pattern19_0 =
10126                                                                     C::inst_data(ctx, pattern18_0);
10127                                                                 if let &InstructionData::Unary {
10128                                                                     opcode: ref pattern20_0,
10129                                                                     arg: pattern20_1,
10130                                                                 } = &pattern19_0
10131                                                                 {
10132                                                                     if let &Opcode::SwidenHigh =
10133                                                                         pattern20_0
10134                                                                     {
10135                                                                         let pattern22_0 =
10136                                                                             C::value_type(
10137                                                                                 ctx,
10138                                                                                 pattern20_1,
10139                                                                             );
10140                                                                         if let Some((
10141                                                                             pattern23_0,
10142                                                                             pattern23_1,
10143                                                                         )) = C::multi_lane(
10144                                                                             ctx,
10145                                                                             pattern22_0,
10146                                                                         ) {
10147                                                                             if pattern23_0 == 32 {
10148                                                                                 if pattern23_1 == 4
10149                                                                                 {
10150                                                                                     // Rule at src/isa/x64/lower.isle line 1066.
10151                                                                                     let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern12_1)?;
10152                                                                                     let expr1_0: u8 = 250;
10153                                                                                     let expr2_0 = OperandSize::Size32;
10154                                                                                     let expr3_0 = constructor_x64_pshufd(ctx, &expr0_0, expr1_0, &expr2_0)?;
10155                                                                                     let expr4_0 = constructor_put_in_xmm_mem(ctx, pattern20_1)?;
10156                                                                                     let expr5_0: u8 = 250;
10157                                                                                     let expr6_0 = OperandSize::Size32;
10158                                                                                     let expr7_0 = constructor_x64_pshufd(ctx, &expr4_0, expr5_0, &expr6_0)?;
10159                                                                                     let expr8_0 = C::xmm_to_xmm_mem(ctx, expr7_0);
10160                                                                                     let expr9_0 = constructor_x64_pmuldq(ctx, expr3_0, &expr8_0)?;
10161                                                                                     let expr10_0 = constructor_output_xmm(ctx, expr9_0)?;
10162                                                                                     return Some(
10163                                                                                         expr10_0,
10164                                                                                     );
10165                                                                                 }
10166                                                                             }
10167                                                                         }
10168                                                                     }
10169                                                                 }
10170                                                             }
10171                                                         }
10172                                                     }
10173                                                 }
10174                                             }
10175                                             &Opcode::UwidenLow => {
10176                                                 let pattern14_0 = C::value_type(ctx, pattern12_1);
10177                                                 if let Some((pattern15_0, pattern15_1)) =
10178                                                     C::multi_lane(ctx, pattern14_0)
10179                                                 {
10180                                                     if pattern15_0 == 32 {
10181                                                         if pattern15_1 == 4 {
10182                                                             if let Some(pattern18_0) =
10183                                                                 C::def_inst(ctx, pattern9_1)
10184                                                             {
10185                                                                 let pattern19_0 =
10186                                                                     C::inst_data(ctx, pattern18_0);
10187                                                                 if let &InstructionData::Unary {
10188                                                                     opcode: ref pattern20_0,
10189                                                                     arg: pattern20_1,
10190                                                                 } = &pattern19_0
10191                                                                 {
10192                                                                     if let &Opcode::UwidenLow =
10193                                                                         pattern20_0
10194                                                                     {
10195                                                                         let pattern22_0 =
10196                                                                             C::value_type(
10197                                                                                 ctx,
10198                                                                                 pattern20_1,
10199                                                                             );
10200                                                                         if let Some((
10201                                                                             pattern23_0,
10202                                                                             pattern23_1,
10203                                                                         )) = C::multi_lane(
10204                                                                             ctx,
10205                                                                             pattern22_0,
10206                                                                         ) {
10207                                                                             if pattern23_0 == 32 {
10208                                                                                 if pattern23_1 == 4
10209                                                                                 {
10210                                                                                     // Rule at src/isa/x64/lower.isle line 1178.
10211                                                                                     let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern12_1)?;
10212                                                                                     let expr1_0: u8 = 80;
10213                                                                                     let expr2_0 = OperandSize::Size32;
10214                                                                                     let expr3_0 = constructor_x64_pshufd(ctx, &expr0_0, expr1_0, &expr2_0)?;
10215                                                                                     let expr4_0 = constructor_put_in_xmm_mem(ctx, pattern20_1)?;
10216                                                                                     let expr5_0: u8 = 80;
10217                                                                                     let expr6_0 = OperandSize::Size32;
10218                                                                                     let expr7_0 = constructor_x64_pshufd(ctx, &expr4_0, expr5_0, &expr6_0)?;
10219                                                                                     let expr8_0 = C::xmm_to_xmm_mem(ctx, expr7_0);
10220                                                                                     let expr9_0 = constructor_x64_pmuludq(ctx, expr3_0, &expr8_0)?;
10221                                                                                     let expr10_0 = constructor_output_xmm(ctx, expr9_0)?;
10222                                                                                     return Some(
10223                                                                                         expr10_0,
10224                                                                                     );
10225                                                                                 }
10226                                                                             }
10227                                                                         }
10228                                                                     }
10229                                                                 }
10230                                                             }
10231                                                         }
10232                                                     }
10233                                                 }
10234                                             }
10235                                             &Opcode::UwidenHigh => {
10236                                                 let pattern14_0 = C::value_type(ctx, pattern12_1);
10237                                                 if let Some((pattern15_0, pattern15_1)) =
10238                                                     C::multi_lane(ctx, pattern14_0)
10239                                                 {
10240                                                     if pattern15_0 == 32 {
10241                                                         if pattern15_1 == 4 {
10242                                                             if let Some(pattern18_0) =
10243                                                                 C::def_inst(ctx, pattern9_1)
10244                                                             {
10245                                                                 let pattern19_0 =
10246                                                                     C::inst_data(ctx, pattern18_0);
10247                                                                 if let &InstructionData::Unary {
10248                                                                     opcode: ref pattern20_0,
10249                                                                     arg: pattern20_1,
10250                                                                 } = &pattern19_0
10251                                                                 {
10252                                                                     if let &Opcode::UwidenHigh =
10253                                                                         pattern20_0
10254                                                                     {
10255                                                                         let pattern22_0 =
10256                                                                             C::value_type(
10257                                                                                 ctx,
10258                                                                                 pattern20_1,
10259                                                                             );
10260                                                                         if let Some((
10261                                                                             pattern23_0,
10262                                                                             pattern23_1,
10263                                                                         )) = C::multi_lane(
10264                                                                             ctx,
10265                                                                             pattern22_0,
10266                                                                         ) {
10267                                                                             if pattern23_0 == 32 {
10268                                                                                 if pattern23_1 == 4
10269                                                                                 {
10270                                                                                     // Rule at src/isa/x64/lower.isle line 1142.
10271                                                                                     let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern12_1)?;
10272                                                                                     let expr1_0: u8 = 250;
10273                                                                                     let expr2_0 = OperandSize::Size32;
10274                                                                                     let expr3_0 = constructor_x64_pshufd(ctx, &expr0_0, expr1_0, &expr2_0)?;
10275                                                                                     let expr4_0 = constructor_put_in_xmm_mem(ctx, pattern20_1)?;
10276                                                                                     let expr5_0: u8 = 250;
10277                                                                                     let expr6_0 = OperandSize::Size32;
10278                                                                                     let expr7_0 = constructor_x64_pshufd(ctx, &expr4_0, expr5_0, &expr6_0)?;
10279                                                                                     let expr8_0 = C::xmm_to_xmm_mem(ctx, expr7_0);
10280                                                                                     let expr9_0 = constructor_x64_pmuludq(ctx, expr3_0, &expr8_0)?;
10281                                                                                     let expr10_0 = constructor_output_xmm(ctx, expr9_0)?;
10282                                                                                     return Some(
10283                                                                                         expr10_0,
10284                                                                                     );
10285                                                                                 }
10286                                                                             }
10287                                                                         }
10288                                                                     }
10289                                                                 }
10290                                                             }
10291                                                         }
10292                                                     }
10293                                                 }
10294                                             }
10295                                             _ => {}
10296                                         }
10297                                     }
10298                                 }
10299                                 // Rule at src/isa/x64/lower.isle line 1018.
10300                                 let expr0_0 = constructor_put_in_xmm(ctx, pattern9_0)?;
10301                                 let expr1_0 = constructor_put_in_xmm(ctx, pattern9_1)?;
10302                                 let expr2_0: u32 = 32;
10303                                 let expr3_0 = RegMemImm::Imm { simm32: expr2_0 };
10304                                 let expr4_0 = constructor_mov_rmi_to_xmm(ctx, &expr3_0)?;
10305                                 let expr5_0 = constructor_x64_psrlq(ctx, expr0_0, &expr4_0)?;
10306                                 let expr6_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
10307                                 let expr7_0 = constructor_x64_pmuludq(ctx, expr5_0, &expr6_0)?;
10308                                 let expr8_0: u32 = 32;
10309                                 let expr9_0 = RegMemImm::Imm { simm32: expr8_0 };
10310                                 let expr10_0 = constructor_mov_rmi_to_xmm(ctx, &expr9_0)?;
10311                                 let expr11_0 = constructor_x64_psrlq(ctx, expr1_0, &expr10_0)?;
10312                                 let expr12_0 = C::xmm_to_xmm_mem(ctx, expr11_0);
10313                                 let expr13_0 = constructor_x64_pmuludq(ctx, expr0_0, &expr12_0)?;
10314                                 let expr14_0 = C::xmm_to_xmm_mem(ctx, expr13_0);
10315                                 let expr15_0 = constructor_x64_paddq(ctx, expr7_0, &expr14_0)?;
10316                                 let expr16_0: u32 = 32;
10317                                 let expr17_0 = RegMemImm::Imm { simm32: expr16_0 };
10318                                 let expr18_0 = constructor_mov_rmi_to_xmm(ctx, &expr17_0)?;
10319                                 let expr19_0 = constructor_x64_psllq(ctx, expr15_0, &expr18_0)?;
10320                                 let expr20_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
10321                                 let expr21_0 = constructor_x64_pmuludq(ctx, expr0_0, &expr20_0)?;
10322                                 let expr22_0 = C::xmm_to_xmm_mem(ctx, expr19_0);
10323                                 let expr23_0 = constructor_x64_paddq(ctx, expr21_0, &expr22_0)?;
10324                                 let expr24_0 = constructor_output_xmm(ctx, expr23_0)?;
10325                                 return Some(expr24_0);
10326                             }
10327                             _ => {}
10328                         }
10329                     }
10330                 }
10331             }
10332             let pattern4_0 = C::inst_data(ctx, pattern0_0);
10333             match &pattern4_0 {
10334                 &InstructionData::Binary {
10335                     opcode: ref pattern5_0,
10336                     args: ref pattern5_1,
10337                 } => {
10338                     match pattern5_0 {
10339                         &Opcode::Band => {
10340                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
10341                             // Rule at src/isa/x64/lower.isle line 328.
10342                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
10343                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
10344                             let expr2_0 = constructor_sse_and(ctx, pattern2_0, expr0_0, &expr1_0)?;
10345                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
10346                             return Some(expr3_0);
10347                         }
10348                         &Opcode::Bor => {
10349                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
10350                             // Rule at src/isa/x64/lower.isle line 392.
10351                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
10352                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
10353                             let expr2_0 = constructor_sse_or(ctx, pattern2_0, expr0_0, &expr1_0)?;
10354                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
10355                             return Some(expr3_0);
10356                         }
10357                         &Opcode::Bxor => {
10358                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
10359                             // Rule at src/isa/x64/lower.isle line 453.
10360                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
10361                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
10362                             let expr2_0 = constructor_sse_xor(ctx, pattern2_0, expr0_0, &expr1_0)?;
10363                             let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
10364                             return Some(expr3_0);
10365                         }
10366                         _ => {}
10367                     }
10368                 }
10369                 &InstructionData::Ternary {
10370                     opcode: ref pattern5_0,
10371                     args: ref pattern5_1,
10372                 } => {
10373                     match pattern5_0 {
10374                         &Opcode::Bitselect => {
10375                             let (pattern7_0, pattern7_1, pattern7_2) =
10376                                 C::unpack_value_array_3(ctx, pattern5_1);
10377                             // Rule at src/isa/x64/lower.isle line 1279.
10378                             let expr0_0 = constructor_put_in_xmm(ctx, pattern7_0)?;
10379                             let expr1_0 = constructor_put_in_xmm(ctx, pattern7_1)?;
10380                             let expr2_0 = C::xmm_to_xmm_mem(ctx, expr0_0);
10381                             let expr3_0 = constructor_sse_and(ctx, pattern2_0, expr1_0, &expr2_0)?;
10382                             let expr4_0 = constructor_put_in_xmm_mem(ctx, pattern7_2)?;
10383                             let expr5_0 =
10384                                 constructor_sse_and_not(ctx, pattern2_0, expr0_0, &expr4_0)?;
10385                             let expr6_0 = C::xmm_to_xmm_mem(ctx, expr3_0);
10386                             let expr7_0 = constructor_sse_or(ctx, pattern2_0, expr5_0, &expr6_0)?;
10387                             let expr8_0 = constructor_output_xmm(ctx, expr7_0)?;
10388                             return Some(expr8_0);
10389                         }
10390                         &Opcode::Vselect => {
10391                             let (pattern7_0, pattern7_1, pattern7_2) =
10392                                 C::unpack_value_array_3(ctx, pattern5_1);
10393                             // Rule at src/isa/x64/lower.isle line 1293.
10394                             let expr0_0 = constructor_put_in_xmm_mem(ctx, pattern7_0)?;
10395                             let expr1_0 = constructor_put_in_xmm_mem(ctx, pattern7_1)?;
10396                             let expr2_0 = constructor_put_in_xmm(ctx, pattern7_2)?;
10397                             let expr3_0 = constructor_x64_blend(
10398                                 ctx, pattern2_0, &expr0_0, &expr1_0, expr2_0,
10399                             )?;
10400                             let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
10401                             return Some(expr4_0);
10402                         }
10403                         _ => {}
10404                     }
10405                 }
10406                 &InstructionData::Unary {
10407                     opcode: ref pattern5_0,
10408                     arg: pattern5_1,
10409                 } => {
10410                     if let &Opcode::Bnot = pattern5_0 {
10411                         // Rule at src/isa/x64/lower.isle line 1274.
10412                         let expr0_0 = constructor_put_in_xmm(ctx, pattern5_1)?;
10413                         let expr1_0 = constructor_vector_all_ones(ctx, pattern2_0)?;
10414                         let expr2_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
10415                         let expr3_0 = constructor_sse_xor(ctx, pattern2_0, expr0_0, &expr2_0)?;
10416                         let expr4_0 = constructor_output_xmm(ctx, expr3_0)?;
10417                         return Some(expr4_0);
10418                     }
10419                 }
10420                 _ => {}
10421             }
10422         }
10423         if let Some(pattern3_0) = C::fits_in_32(ctx, pattern2_0) {
10424             let pattern4_0 = C::inst_data(ctx, pattern0_0);
10425             if let &InstructionData::Unary {
10426                 opcode: ref pattern5_0,
10427                 arg: pattern5_1,
10428             } = &pattern4_0
10429             {
10430                 if let &Opcode::Uextend = pattern5_0 {
10431                     let pattern7_0 = C::value_type(ctx, pattern5_1);
10432                     if let Some(pattern8_0) = C::fits_in_32(ctx, pattern7_0) {
10433                         // Rule at src/isa/x64/lower.isle line 2130.
10434                         let expr0_0: Type = I32;
10435                         let expr1_0 = ExtendKind::Zero;
10436                         let expr2_0 =
10437                             constructor_extend_to_gpr(ctx, pattern5_1, expr0_0, &expr1_0)?;
10438                         let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
10439                         return Some(expr3_0);
10440                     }
10441                 }
10442             }
10443             if let Some(pattern4_0) = C::is_gpr_type(ctx, pattern2_0) {
10444                 let pattern5_0 = C::inst_data(ctx, pattern0_0);
10445                 if let &InstructionData::Load {
10446                     opcode: ref pattern6_0,
10447                     arg: pattern6_1,
10448                     flags: pattern6_2,
10449                     offset: pattern6_3,
10450                 } = &pattern5_0
10451                 {
10452                     if let &Opcode::Load = pattern6_0 {
10453                         // Rule at src/isa/x64/lower.isle line 2520.
10454                         let expr0_0 = C::ty_bits_u16(ctx, pattern3_0);
10455                         let expr1_0: u16 = 64;
10456                         let expr2_0 = C::ext_mode(ctx, expr0_0, expr1_0);
10457                         let expr3_0 =
10458                             constructor_to_amode(ctx, pattern6_2, pattern6_1, pattern6_3)?;
10459                         let expr4_0 = constructor_amode_to_gpr_mem(ctx, &expr3_0)?;
10460                         let expr5_0 = constructor_x64_movzx(ctx, &expr2_0, &expr4_0)?;
10461                         let expr6_0 = constructor_output_gpr(ctx, expr5_0)?;
10462                         return Some(expr6_0);
10463                     }
10464                 }
10465             }
10466         }
10467         if let Some(pattern3_0) = C::fits_in_64(ctx, pattern2_0) {
10468             let pattern4_0 = C::inst_data(ctx, pattern0_0);
10469             match &pattern4_0 {
10470                 &InstructionData::UnaryImm {
10471                     opcode: ref pattern5_0,
10472                     imm: pattern5_1,
10473                 } => {
10474                     if let &Opcode::Iconst = pattern5_0 {
10475                         let pattern7_0 = C::u64_from_imm64(ctx, pattern5_1);
10476                         // Rule at src/isa/x64/lower.isle line 10.
10477                         let expr0_0 = constructor_imm(ctx, pattern3_0, pattern7_0)?;
10478                         let expr1_0 = constructor_output_reg(ctx, expr0_0)?;
10479                         return Some(expr1_0);
10480                     }
10481                 }
10482                 &InstructionData::UnaryBool {
10483                     opcode: ref pattern5_0,
10484                     imm: pattern5_1,
10485                 } => {
10486                     if let &Opcode::Bconst = pattern5_0 {
10487                         if pattern5_1 == true {
10488                             // Rule at src/isa/x64/lower.isle line 28.
10489                             let expr0_0: u64 = 1;
10490                             let expr1_0 = constructor_imm(ctx, pattern3_0, expr0_0)?;
10491                             let expr2_0 = constructor_output_reg(ctx, expr1_0)?;
10492                             return Some(expr2_0);
10493                         }
10494                         if pattern5_1 == false {
10495                             // Rule at src/isa/x64/lower.isle line 24.
10496                             let expr0_0: u64 = 0;
10497                             let expr1_0 = constructor_imm(ctx, pattern3_0, expr0_0)?;
10498                             let expr2_0 = constructor_output_reg(ctx, expr1_0)?;
10499                             return Some(expr2_0);
10500                         }
10501                     }
10502                 }
10503                 &InstructionData::Binary {
10504                     opcode: ref pattern5_0,
10505                     args: ref pattern5_1,
10506                 } => {
10507                     match pattern5_0 {
10508                         &Opcode::Imin => {
10509                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
10510                             // Rule at src/isa/x64/lower.isle line 1386.
10511                             let expr0_0 = CC::L;
10512                             let expr1_0 = constructor_cmp_and_choose(
10513                                 ctx, pattern3_0, &expr0_0, pattern7_0, pattern7_1,
10514                             )?;
10515                             let expr2_0 = C::output(ctx, expr1_0);
10516                             return Some(expr2_0);
10517                         }
10518                         &Opcode::Umin => {
10519                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
10520                             // Rule at src/isa/x64/lower.isle line 1380.
10521                             let expr0_0 = CC::B;
10522                             let expr1_0 = constructor_cmp_and_choose(
10523                                 ctx, pattern3_0, &expr0_0, pattern7_0, pattern7_1,
10524                             )?;
10525                             let expr2_0 = C::output(ctx, expr1_0);
10526                             return Some(expr2_0);
10527                         }
10528                         &Opcode::Imax => {
10529                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
10530                             // Rule at src/isa/x64/lower.isle line 1389.
10531                             let expr0_0 = CC::NL;
10532                             let expr1_0 = constructor_cmp_and_choose(
10533                                 ctx, pattern3_0, &expr0_0, pattern7_0, pattern7_1,
10534                             )?;
10535                             let expr2_0 = C::output(ctx, expr1_0);
10536                             return Some(expr2_0);
10537                         }
10538                         &Opcode::Umax => {
10539                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
10540                             // Rule at src/isa/x64/lower.isle line 1383.
10541                             let expr0_0 = CC::NB;
10542                             let expr1_0 = constructor_cmp_and_choose(
10543                                 ctx, pattern3_0, &expr0_0, pattern7_0, pattern7_1,
10544                             )?;
10545                             let expr2_0 = C::output(ctx, expr1_0);
10546                             return Some(expr2_0);
10547                         }
10548                         &Opcode::Iadd => {
10549                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
10550                             if let Some(pattern8_0) = C::simm32_from_value(ctx, pattern7_0) {
10551                                 // Rule at src/isa/x64/lower.isle line 74.
10552                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_1)?;
10553                                 let expr1_0 =
10554                                     constructor_x64_add(ctx, pattern3_0, expr0_0, &pattern8_0)?;
10555                                 let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
10556                                 return Some(expr2_0);
10557                             }
10558                             if let Some(pattern8_0) = C::sinkable_load(ctx, pattern7_0) {
10559                                 // Rule at src/isa/x64/lower.isle line 86.
10560                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_1)?;
10561                                 let expr1_0 =
10562                                     constructor_sink_load_to_gpr_mem_imm(ctx, &pattern8_0)?;
10563                                 let expr2_0 =
10564                                     constructor_x64_add(ctx, pattern3_0, expr0_0, &expr1_0)?;
10565                                 let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
10566                                 return Some(expr3_0);
10567                             }
10568                             if let Some(pattern8_0) = C::simm32_from_value(ctx, pattern7_1) {
10569                                 // Rule at src/isa/x64/lower.isle line 70.
10570                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
10571                                 let expr1_0 =
10572                                     constructor_x64_add(ctx, pattern3_0, expr0_0, &pattern8_0)?;
10573                                 let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
10574                                 return Some(expr2_0);
10575                             }
10576                             if let Some(pattern8_0) = C::sinkable_load(ctx, pattern7_1) {
10577                                 // Rule at src/isa/x64/lower.isle line 80.
10578                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
10579                                 let expr1_0 =
10580                                     constructor_sink_load_to_gpr_mem_imm(ctx, &pattern8_0)?;
10581                                 let expr2_0 =
10582                                     constructor_x64_add(ctx, pattern3_0, expr0_0, &expr1_0)?;
10583                                 let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
10584                                 return Some(expr3_0);
10585                             }
10586                             // Rule at src/isa/x64/lower.isle line 64.
10587                             let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
10588                             let expr1_0 = constructor_put_in_gpr_mem_imm(ctx, pattern7_1)?;
10589                             let expr2_0 = constructor_x64_add(ctx, pattern3_0, expr0_0, &expr1_0)?;
10590                             let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
10591                             return Some(expr3_0);
10592                         }
10593                         &Opcode::Isub => {
10594                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
10595                             if let Some(pattern8_0) = C::simm32_from_value(ctx, pattern7_1) {
10596                                 // Rule at src/isa/x64/lower.isle line 228.
10597                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
10598                                 let expr1_0 =
10599                                     constructor_x64_sub(ctx, pattern3_0, expr0_0, &pattern8_0)?;
10600                                 let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
10601                                 return Some(expr2_0);
10602                             }
10603                             if let Some(pattern8_0) = C::sinkable_load(ctx, pattern7_1) {
10604                                 // Rule at src/isa/x64/lower.isle line 233.
10605                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
10606                                 let expr1_0 =
10607                                     constructor_sink_load_to_gpr_mem_imm(ctx, &pattern8_0)?;
10608                                 let expr2_0 =
10609                                     constructor_x64_sub(ctx, pattern3_0, expr0_0, &expr1_0)?;
10610                                 let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
10611                                 return Some(expr3_0);
10612                             }
10613                             // Rule at src/isa/x64/lower.isle line 223.
10614                             let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
10615                             let expr1_0 = constructor_put_in_gpr_mem_imm(ctx, pattern7_1)?;
10616                             let expr2_0 = constructor_x64_sub(ctx, pattern3_0, expr0_0, &expr1_0)?;
10617                             let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
10618                             return Some(expr3_0);
10619                         }
10620                         &Opcode::Imul => {
10621                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
10622                             if let Some(pattern8_0) = C::simm32_from_value(ctx, pattern7_0) {
10623                                 // Rule at src/isa/x64/lower.isle line 925.
10624                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_1)?;
10625                                 let expr1_0 =
10626                                     constructor_x64_mul(ctx, pattern3_0, expr0_0, &pattern8_0)?;
10627                                 let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
10628                                 return Some(expr2_0);
10629                             }
10630                             if let Some(pattern8_0) = C::sinkable_load(ctx, pattern7_0) {
10631                                 // Rule at src/isa/x64/lower.isle line 937.
10632                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_1)?;
10633                                 let expr1_0 =
10634                                     constructor_sink_load_to_gpr_mem_imm(ctx, &pattern8_0)?;
10635                                 let expr2_0 =
10636                                     constructor_x64_mul(ctx, pattern3_0, expr0_0, &expr1_0)?;
10637                                 let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
10638                                 return Some(expr3_0);
10639                             }
10640                             if let Some(pattern8_0) = C::simm32_from_value(ctx, pattern7_1) {
10641                                 // Rule at src/isa/x64/lower.isle line 921.
10642                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
10643                                 let expr1_0 =
10644                                     constructor_x64_mul(ctx, pattern3_0, expr0_0, &pattern8_0)?;
10645                                 let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
10646                                 return Some(expr2_0);
10647                             }
10648                             if let Some(pattern8_0) = C::sinkable_load(ctx, pattern7_1) {
10649                                 // Rule at src/isa/x64/lower.isle line 931.
10650                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
10651                                 let expr1_0 =
10652                                     constructor_sink_load_to_gpr_mem_imm(ctx, &pattern8_0)?;
10653                                 let expr2_0 =
10654                                     constructor_x64_mul(ctx, pattern3_0, expr0_0, &expr1_0)?;
10655                                 let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
10656                                 return Some(expr3_0);
10657                             }
10658                             // Rule at src/isa/x64/lower.isle line 916.
10659                             let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
10660                             let expr1_0 = constructor_put_in_gpr_mem_imm(ctx, pattern7_1)?;
10661                             let expr2_0 = constructor_x64_mul(ctx, pattern3_0, expr0_0, &expr1_0)?;
10662                             let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
10663                             return Some(expr3_0);
10664                         }
10665                         &Opcode::IaddIfcout => {
10666                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
10667                             if let Some(pattern8_0) = C::simm32_from_value(ctx, pattern7_0) {
10668                                 // Rule at src/isa/x64/lower.isle line 171.
10669                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_1)?;
10670                                 let expr1_0 =
10671                                     constructor_x64_add(ctx, pattern3_0, expr0_0, &pattern8_0)?;
10672                                 let expr2_0 = C::gpr_to_reg(ctx, expr1_0);
10673                                 let expr3_0 = constructor_output_ifcout(ctx, expr2_0)?;
10674                                 return Some(expr3_0);
10675                             }
10676                             if let Some(pattern8_0) = C::sinkable_load(ctx, pattern7_0) {
10677                                 // Rule at src/isa/x64/lower.isle line 181.
10678                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_1)?;
10679                                 let expr1_0 =
10680                                     constructor_sink_load_to_gpr_mem_imm(ctx, &pattern8_0)?;
10681                                 let expr2_0 =
10682                                     constructor_x64_add(ctx, pattern3_0, expr0_0, &expr1_0)?;
10683                                 let expr3_0 = C::gpr_to_reg(ctx, expr2_0);
10684                                 let expr4_0 = constructor_output_ifcout(ctx, expr3_0)?;
10685                                 return Some(expr4_0);
10686                             }
10687                             if let Some(pattern8_0) = C::simm32_from_value(ctx, pattern7_1) {
10688                                 // Rule at src/isa/x64/lower.isle line 167.
10689                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
10690                                 let expr1_0 =
10691                                     constructor_x64_add(ctx, pattern3_0, expr0_0, &pattern8_0)?;
10692                                 let expr2_0 = C::gpr_to_reg(ctx, expr1_0);
10693                                 let expr3_0 = constructor_output_ifcout(ctx, expr2_0)?;
10694                                 return Some(expr3_0);
10695                             }
10696                             if let Some(pattern8_0) = C::sinkable_load(ctx, pattern7_1) {
10697                                 // Rule at src/isa/x64/lower.isle line 177.
10698                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
10699                                 let expr1_0 =
10700                                     constructor_sink_load_to_gpr_mem_imm(ctx, &pattern8_0)?;
10701                                 let expr2_0 =
10702                                     constructor_x64_add(ctx, pattern3_0, expr0_0, &expr1_0)?;
10703                                 let expr3_0 = C::gpr_to_reg(ctx, expr2_0);
10704                                 let expr4_0 = constructor_output_ifcout(ctx, expr3_0)?;
10705                                 return Some(expr4_0);
10706                             }
10707                             // Rule at src/isa/x64/lower.isle line 161.
10708                             let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
10709                             let expr1_0 = constructor_put_in_gpr_mem_imm(ctx, pattern7_1)?;
10710                             let expr2_0 = constructor_x64_add(ctx, pattern3_0, expr0_0, &expr1_0)?;
10711                             let expr3_0 = C::gpr_to_reg(ctx, expr2_0);
10712                             let expr4_0 = constructor_output_ifcout(ctx, expr3_0)?;
10713                             return Some(expr4_0);
10714                         }
10715                         &Opcode::Band => {
10716                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
10717                             if let Some(pattern8_0) = C::simm32_from_value(ctx, pattern7_0) {
10718                                 // Rule at src/isa/x64/lower.isle line 317.
10719                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_1)?;
10720                                 let expr1_0 =
10721                                     constructor_x64_and(ctx, pattern3_0, expr0_0, &pattern8_0)?;
10722                                 let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
10723                                 return Some(expr2_0);
10724                             }
10725                             if let Some(pattern8_0) = C::sinkable_load(ctx, pattern7_0) {
10726                                 // Rule at src/isa/x64/lower.isle line 305.
10727                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_1)?;
10728                                 let expr1_0 =
10729                                     constructor_sink_load_to_gpr_mem_imm(ctx, &pattern8_0)?;
10730                                 let expr2_0 =
10731                                     constructor_x64_and(ctx, pattern3_0, expr0_0, &expr1_0)?;
10732                                 let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
10733                                 return Some(expr3_0);
10734                             }
10735                             if let Some(pattern8_0) = C::simm32_from_value(ctx, pattern7_1) {
10736                                 // Rule at src/isa/x64/lower.isle line 313.
10737                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
10738                                 let expr1_0 =
10739                                     constructor_x64_and(ctx, pattern3_0, expr0_0, &pattern8_0)?;
10740                                 let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
10741                                 return Some(expr2_0);
10742                             }
10743                             if let Some(pattern8_0) = C::sinkable_load(ctx, pattern7_1) {
10744                                 // Rule at src/isa/x64/lower.isle line 300.
10745                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
10746                                 let expr1_0 =
10747                                     constructor_sink_load_to_gpr_mem_imm(ctx, &pattern8_0)?;
10748                                 let expr2_0 =
10749                                     constructor_x64_and(ctx, pattern3_0, expr0_0, &expr1_0)?;
10750                                 let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
10751                                 return Some(expr3_0);
10752                             }
10753                             // Rule at src/isa/x64/lower.isle line 295.
10754                             let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
10755                             let expr1_0 = constructor_put_in_gpr_mem_imm(ctx, pattern7_1)?;
10756                             let expr2_0 = constructor_x64_and(ctx, pattern3_0, expr0_0, &expr1_0)?;
10757                             let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
10758                             return Some(expr3_0);
10759                         }
10760                         &Opcode::Bor => {
10761                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
10762                             if let Some(pattern8_0) = C::simm32_from_value(ctx, pattern7_0) {
10763                                 // Rule at src/isa/x64/lower.isle line 381.
10764                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_1)?;
10765                                 let expr1_0 =
10766                                     constructor_x64_or(ctx, pattern3_0, expr0_0, &pattern8_0)?;
10767                                 let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
10768                                 return Some(expr2_0);
10769                             }
10770                             if let Some(pattern8_0) = C::sinkable_load(ctx, pattern7_0) {
10771                                 // Rule at src/isa/x64/lower.isle line 370.
10772                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_1)?;
10773                                 let expr1_0 =
10774                                     constructor_sink_load_to_gpr_mem_imm(ctx, &pattern8_0)?;
10775                                 let expr2_0 =
10776                                     constructor_x64_or(ctx, pattern3_0, expr0_0, &expr1_0)?;
10777                                 let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
10778                                 return Some(expr3_0);
10779                             }
10780                             if let Some(pattern8_0) = C::simm32_from_value(ctx, pattern7_1) {
10781                                 // Rule at src/isa/x64/lower.isle line 377.
10782                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
10783                                 let expr1_0 =
10784                                     constructor_x64_or(ctx, pattern3_0, expr0_0, &pattern8_0)?;
10785                                 let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
10786                                 return Some(expr2_0);
10787                             }
10788                             if let Some(pattern8_0) = C::sinkable_load(ctx, pattern7_1) {
10789                                 // Rule at src/isa/x64/lower.isle line 365.
10790                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
10791                                 let expr1_0 =
10792                                     constructor_sink_load_to_gpr_mem_imm(ctx, &pattern8_0)?;
10793                                 let expr2_0 =
10794                                     constructor_x64_or(ctx, pattern3_0, expr0_0, &expr1_0)?;
10795                                 let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
10796                                 return Some(expr3_0);
10797                             }
10798                             // Rule at src/isa/x64/lower.isle line 360.
10799                             let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
10800                             let expr1_0 = constructor_put_in_gpr_mem_imm(ctx, pattern7_1)?;
10801                             let expr2_0 = constructor_x64_or(ctx, pattern3_0, expr0_0, &expr1_0)?;
10802                             let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
10803                             return Some(expr3_0);
10804                         }
10805                         &Opcode::Bxor => {
10806                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
10807                             if let Some(pattern8_0) = C::simm32_from_value(ctx, pattern7_0) {
10808                                 // Rule at src/isa/x64/lower.isle line 447.
10809                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_1)?;
10810                                 let expr1_0 =
10811                                     constructor_x64_xor(ctx, pattern3_0, expr0_0, &pattern8_0)?;
10812                                 let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
10813                                 return Some(expr2_0);
10814                             }
10815                             if let Some(pattern8_0) = C::sinkable_load(ctx, pattern7_0) {
10816                                 // Rule at src/isa/x64/lower.isle line 436.
10817                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_1)?;
10818                                 let expr1_0 =
10819                                     constructor_sink_load_to_gpr_mem_imm(ctx, &pattern8_0)?;
10820                                 let expr2_0 =
10821                                     constructor_x64_xor(ctx, pattern3_0, expr0_0, &expr1_0)?;
10822                                 let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
10823                                 return Some(expr3_0);
10824                             }
10825                             if let Some(pattern8_0) = C::simm32_from_value(ctx, pattern7_1) {
10826                                 // Rule at src/isa/x64/lower.isle line 443.
10827                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
10828                                 let expr1_0 =
10829                                     constructor_x64_xor(ctx, pattern3_0, expr0_0, &pattern8_0)?;
10830                                 let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
10831                                 return Some(expr2_0);
10832                             }
10833                             if let Some(pattern8_0) = C::sinkable_load(ctx, pattern7_1) {
10834                                 // Rule at src/isa/x64/lower.isle line 431.
10835                                 let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
10836                                 let expr1_0 =
10837                                     constructor_sink_load_to_gpr_mem_imm(ctx, &pattern8_0)?;
10838                                 let expr2_0 =
10839                                     constructor_x64_xor(ctx, pattern3_0, expr0_0, &expr1_0)?;
10840                                 let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
10841                                 return Some(expr3_0);
10842                             }
10843                             // Rule at src/isa/x64/lower.isle line 426.
10844                             let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
10845                             let expr1_0 = constructor_put_in_gpr_mem_imm(ctx, pattern7_1)?;
10846                             let expr2_0 = constructor_x64_xor(ctx, pattern3_0, expr0_0, &expr1_0)?;
10847                             let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
10848                             return Some(expr3_0);
10849                         }
10850                         &Opcode::Ishl => {
10851                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
10852                             // Rule at src/isa/x64/lower.isle line 483.
10853                             let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
10854                             let expr1_0 = C::put_masked_in_imm8_gpr(ctx, pattern7_1, pattern3_0);
10855                             let expr2_0 = constructor_x64_shl(ctx, pattern3_0, expr0_0, &expr1_0)?;
10856                             let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
10857                             return Some(expr3_0);
10858                         }
10859                         &Opcode::Ushr => {
10860                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
10861                             // Rule at src/isa/x64/lower.isle line 589.
10862                             let expr0_0 = ExtendKind::Zero;
10863                             let expr1_0 =
10864                                 constructor_extend_to_gpr(ctx, pattern7_0, pattern3_0, &expr0_0)?;
10865                             let expr2_0 = C::put_masked_in_imm8_gpr(ctx, pattern7_1, pattern3_0);
10866                             let expr3_0 = constructor_x64_shr(ctx, pattern3_0, expr1_0, &expr2_0)?;
10867                             let expr4_0 = constructor_output_gpr(ctx, expr3_0)?;
10868                             return Some(expr4_0);
10869                         }
10870                         &Opcode::Sshr => {
10871                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
10872                             // Rule at src/isa/x64/lower.isle line 691.
10873                             let expr0_0 = ExtendKind::Sign;
10874                             let expr1_0 =
10875                                 constructor_extend_to_gpr(ctx, pattern7_0, pattern3_0, &expr0_0)?;
10876                             let expr2_0 = C::put_masked_in_imm8_gpr(ctx, pattern7_1, pattern3_0);
10877                             let expr3_0 = constructor_x64_sar(ctx, pattern3_0, expr1_0, &expr2_0)?;
10878                             let expr4_0 = constructor_output_gpr(ctx, expr3_0)?;
10879                             return Some(expr4_0);
10880                         }
10881                         _ => {}
10882                     }
10883                 }
10884                 &InstructionData::Unary {
10885                     opcode: ref pattern5_0,
10886                     arg: pattern5_1,
10887                 } => {
10888                     match pattern5_0 {
10889                         &Opcode::Ineg => {
10890                             // Rule at src/isa/x64/lower.isle line 884.
10891                             let expr0_0 = constructor_put_in_gpr(ctx, pattern5_1)?;
10892                             let expr1_0 = constructor_x64_neg(ctx, pattern3_0, expr0_0)?;
10893                             let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
10894                             return Some(expr2_0);
10895                         }
10896                         &Opcode::Bnot => {
10897                             // Rule at src/isa/x64/lower.isle line 1253.
10898                             let expr0_0 = constructor_put_in_gpr(ctx, pattern5_1)?;
10899                             let expr1_0 = constructor_x64_not(ctx, pattern3_0, expr0_0)?;
10900                             let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
10901                             return Some(expr2_0);
10902                         }
10903                         &Opcode::Breduce => {
10904                             // Rule at src/isa/x64/lower.isle line 2235.
10905                             let expr0_0 = C::put_in_regs(ctx, pattern5_1);
10906                             let expr1_0: usize = 0;
10907                             let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?;
10908                             let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
10909                             return Some(expr3_0);
10910                         }
10911                         &Opcode::Bint => {
10912                             // Rule at src/isa/x64/lower.isle line 2243.
10913                             let expr0_0 = constructor_put_in_gpr(ctx, pattern5_1)?;
10914                             let expr1_0: u32 = 1;
10915                             let expr2_0 = RegMemImm::Imm { simm32: expr1_0 };
10916                             let expr3_0 = C::gpr_mem_imm_new(ctx, &expr2_0);
10917                             let expr4_0 = constructor_x64_and(ctx, pattern3_0, expr0_0, &expr3_0)?;
10918                             let expr5_0 = constructor_output_gpr(ctx, expr4_0)?;
10919                             return Some(expr5_0);
10920                         }
10921                         &Opcode::Ireduce => {
10922                             // Rule at src/isa/x64/lower.isle line 2227.
10923                             let expr0_0 = C::put_in_regs(ctx, pattern5_1);
10924                             let expr1_0: usize = 0;
10925                             let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?;
10926                             let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
10927                             return Some(expr3_0);
10928                         }
10929                         _ => {}
10930                     }
10931                 }
10932                 &InstructionData::BinaryImm64 {
10933                     opcode: ref pattern5_0,
10934                     arg: pattern5_1,
10935                     imm: pattern5_2,
10936                 } => {
10937                     if let &Opcode::IaddImm = pattern5_0 {
10938                         let pattern7_0 = C::u64_from_imm64(ctx, pattern5_2);
10939                         // Rule at src/isa/x64/lower.isle line 196.
10940                         let expr0_0 = constructor_put_in_gpr(ctx, pattern5_1)?;
10941                         let expr1_0 = constructor_imm(ctx, pattern3_0, pattern7_0)?;
10942                         let expr2_0 = constructor_reg_to_gpr_mem_imm(ctx, expr1_0)?;
10943                         let expr3_0 = constructor_x64_add(ctx, pattern3_0, expr0_0, &expr2_0)?;
10944                         let expr4_0 = constructor_output_gpr(ctx, expr3_0)?;
10945                         return Some(expr4_0);
10946                     }
10947                 }
10948                 _ => {}
10949             }
10950         }
10951         if let Some(pattern3_0) = C::ty_32_or_64(ctx, pattern2_0) {
10952             let pattern4_0 = C::inst_data(ctx, pattern0_0);
10953             match &pattern4_0 {
10954                 &InstructionData::Binary {
10955                     opcode: ref pattern5_0,
10956                     args: ref pattern5_1,
10957                 } => {
10958                     match pattern5_0 {
10959                         &Opcode::Rotl => {
10960                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
10961                             if let Some(pattern8_0) = C::def_inst(ctx, pattern7_1) {
10962                                 let pattern9_0 = C::inst_data(ctx, pattern8_0);
10963                                 if let &InstructionData::UnaryImm {
10964                                     opcode: ref pattern10_0,
10965                                     imm: pattern10_1,
10966                                 } = &pattern9_0
10967                                 {
10968                                     if let &Opcode::Iconst = pattern10_0 {
10969                                         let pattern12_0 = C::u64_from_imm64(ctx, pattern10_1);
10970                                         // Rule at src/isa/x64/lower.isle line 823.
10971                                         let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
10972                                         let expr1_0 = C::const_to_type_masked_imm8(
10973                                             ctx,
10974                                             pattern12_0,
10975                                             pattern3_0,
10976                                         );
10977                                         let expr2_0 = constructor_x64_rotl(
10978                                             ctx, pattern3_0, expr0_0, &expr1_0,
10979                                         )?;
10980                                         let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
10981                                         return Some(expr3_0);
10982                                     }
10983                                 }
10984                             }
10985                             // Rule at src/isa/x64/lower.isle line 817.
10986                             let expr0_0 = constructor_lo_gpr(ctx, pattern7_1)?;
10987                             let expr1_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
10988                             let expr2_0 = C::gpr_to_imm8_gpr(ctx, expr0_0);
10989                             let expr3_0 = constructor_x64_rotl(ctx, pattern3_0, expr1_0, &expr2_0)?;
10990                             let expr4_0 = constructor_output_gpr(ctx, expr3_0)?;
10991                             return Some(expr4_0);
10992                         }
10993                         &Opcode::Rotr => {
10994                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
10995                             if let Some(pattern8_0) = C::def_inst(ctx, pattern7_1) {
10996                                 let pattern9_0 = C::inst_data(ctx, pattern8_0);
10997                                 if let &InstructionData::UnaryImm {
10998                                     opcode: ref pattern10_0,
10999                                     imm: pattern10_1,
11000                                 } = &pattern9_0
11001                                 {
11002                                     if let &Opcode::Iconst = pattern10_0 {
11003                                         let pattern12_0 = C::u64_from_imm64(ctx, pattern10_1);
11004                                         // Rule at src/isa/x64/lower.isle line 863.
11005                                         let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
11006                                         let expr1_0 = C::const_to_type_masked_imm8(
11007                                             ctx,
11008                                             pattern12_0,
11009                                             pattern3_0,
11010                                         );
11011                                         let expr2_0 = constructor_x64_rotr(
11012                                             ctx, pattern3_0, expr0_0, &expr1_0,
11013                                         )?;
11014                                         let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
11015                                         return Some(expr3_0);
11016                                     }
11017                                 }
11018                             }
11019                             // Rule at src/isa/x64/lower.isle line 857.
11020                             let expr0_0 = constructor_lo_gpr(ctx, pattern7_1)?;
11021                             let expr1_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
11022                             let expr2_0 = C::gpr_to_imm8_gpr(ctx, expr0_0);
11023                             let expr3_0 = constructor_x64_rotr(ctx, pattern3_0, expr1_0, &expr2_0)?;
11024                             let expr4_0 = constructor_output_gpr(ctx, expr3_0)?;
11025                             return Some(expr4_0);
11026                         }
11027                         _ => {}
11028                     }
11029                 }
11030                 &InstructionData::Unary {
11031                     opcode: ref pattern5_0,
11032                     arg: pattern5_1,
11033                 } => {
11034                     match pattern5_0 {
11035                         &Opcode::Clz => {
11036                             // Rule at src/isa/x64/lower.isle line 1791.
11037                             let expr0_0 = constructor_put_in_gpr(ctx, pattern5_1)?;
11038                             let expr1_0 = constructor_do_clz(ctx, pattern3_0, pattern3_0, expr0_0)?;
11039                             let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
11040                             return Some(expr2_0);
11041                         }
11042                         &Opcode::Ctz => {
11043                             // Rule at src/isa/x64/lower.isle line 1833.
11044                             let expr0_0 = constructor_put_in_gpr(ctx, pattern5_1)?;
11045                             let expr1_0 = constructor_do_ctz(ctx, pattern3_0, pattern3_0, expr0_0)?;
11046                             let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
11047                             return Some(expr2_0);
11048                         }
11049                         &Opcode::Popcnt => {
11050                             // Rule at src/isa/x64/lower.isle line 1885.
11051                             let expr0_0 = constructor_put_in_gpr(ctx, pattern5_1)?;
11052                             let expr1_0 = constructor_do_popcnt(ctx, pattern3_0, expr0_0)?;
11053                             let expr2_0 = constructor_output_gpr(ctx, expr1_0)?;
11054                             return Some(expr2_0);
11055                         }
11056                         _ => {}
11057                     }
11058                 }
11059                 _ => {}
11060             }
11061         }
11062         if let Some(pattern3_0) = C::ty_8_or_16(ctx, pattern2_0) {
11063             let pattern4_0 = C::inst_data(ctx, pattern0_0);
11064             match &pattern4_0 {
11065                 &InstructionData::Binary {
11066                     opcode: ref pattern5_0,
11067                     args: ref pattern5_1,
11068                 } => {
11069                     match pattern5_0 {
11070                         &Opcode::Rotl => {
11071                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
11072                             if let Some(pattern8_0) = C::def_inst(ctx, pattern7_1) {
11073                                 let pattern9_0 = C::inst_data(ctx, pattern8_0);
11074                                 if let &InstructionData::UnaryImm {
11075                                     opcode: ref pattern10_0,
11076                                     imm: pattern10_1,
11077                                 } = &pattern9_0
11078                                 {
11079                                     if let &Opcode::Iconst = pattern10_0 {
11080                                         let pattern12_0 = C::u64_from_imm64(ctx, pattern10_1);
11081                                         // Rule at src/isa/x64/lower.isle line 809.
11082                                         let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
11083                                         let expr1_0 = C::const_to_type_masked_imm8(
11084                                             ctx,
11085                                             pattern12_0,
11086                                             pattern3_0,
11087                                         );
11088                                         let expr2_0 = constructor_x64_rotl(
11089                                             ctx, pattern3_0, expr0_0, &expr1_0,
11090                                         )?;
11091                                         let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
11092                                         return Some(expr3_0);
11093                                     }
11094                                 }
11095                             }
11096                             // Rule at src/isa/x64/lower.isle line 805.
11097                             let expr0_0: Type = I32;
11098                             let expr1_0 = ExtendKind::Zero;
11099                             let expr2_0 =
11100                                 constructor_extend_to_gpr(ctx, pattern7_1, expr0_0, &expr1_0)?;
11101                             let expr3_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
11102                             let expr4_0 = C::gpr_to_imm8_gpr(ctx, expr2_0);
11103                             let expr5_0 = constructor_x64_rotl(ctx, pattern3_0, expr3_0, &expr4_0)?;
11104                             let expr6_0 = constructor_output_gpr(ctx, expr5_0)?;
11105                             return Some(expr6_0);
11106                         }
11107                         &Opcode::Rotr => {
11108                             let (pattern7_0, pattern7_1) = C::unpack_value_array_2(ctx, pattern5_1);
11109                             if let Some(pattern8_0) = C::def_inst(ctx, pattern7_1) {
11110                                 let pattern9_0 = C::inst_data(ctx, pattern8_0);
11111                                 if let &InstructionData::UnaryImm {
11112                                     opcode: ref pattern10_0,
11113                                     imm: pattern10_1,
11114                                 } = &pattern9_0
11115                                 {
11116                                     if let &Opcode::Iconst = pattern10_0 {
11117                                         let pattern12_0 = C::u64_from_imm64(ctx, pattern10_1);
11118                                         // Rule at src/isa/x64/lower.isle line 849.
11119                                         let expr0_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
11120                                         let expr1_0 = C::const_to_type_masked_imm8(
11121                                             ctx,
11122                                             pattern12_0,
11123                                             pattern3_0,
11124                                         );
11125                                         let expr2_0 = constructor_x64_rotr(
11126                                             ctx, pattern3_0, expr0_0, &expr1_0,
11127                                         )?;
11128                                         let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
11129                                         return Some(expr3_0);
11130                                     }
11131                                 }
11132                             }
11133                             // Rule at src/isa/x64/lower.isle line 845.
11134                             let expr0_0: Type = I32;
11135                             let expr1_0 = ExtendKind::Zero;
11136                             let expr2_0 =
11137                                 constructor_extend_to_gpr(ctx, pattern7_1, expr0_0, &expr1_0)?;
11138                             let expr3_0 = constructor_put_in_gpr(ctx, pattern7_0)?;
11139                             let expr4_0 = C::gpr_to_imm8_gpr(ctx, expr2_0);
11140                             let expr5_0 = constructor_x64_rotr(ctx, pattern3_0, expr3_0, &expr4_0)?;
11141                             let expr6_0 = constructor_output_gpr(ctx, expr5_0)?;
11142                             return Some(expr6_0);
11143                         }
11144                         _ => {}
11145                     }
11146                 }
11147                 &InstructionData::Unary {
11148                     opcode: ref pattern5_0,
11149                     arg: pattern5_1,
11150                 } => {
11151                     match pattern5_0 {
11152                         &Opcode::Clz => {
11153                             // Rule at src/isa/x64/lower.isle line 1796.
11154                             let expr0_0: Type = I32;
11155                             let expr1_0: Type = I32;
11156                             let expr2_0 = ExtendKind::Zero;
11157                             let expr3_0 =
11158                                 constructor_extend_to_gpr(ctx, pattern5_1, expr1_0, &expr2_0)?;
11159                             let expr4_0 = constructor_do_clz(ctx, expr0_0, pattern3_0, expr3_0)?;
11160                             let expr5_0 = constructor_output_gpr(ctx, expr4_0)?;
11161                             return Some(expr5_0);
11162                         }
11163                         &Opcode::Ctz => {
11164                             // Rule at src/isa/x64/lower.isle line 1838.
11165                             let expr0_0: Type = I32;
11166                             let expr1_0: Type = I32;
11167                             let expr2_0 = ExtendKind::Zero;
11168                             let expr3_0 =
11169                                 constructor_extend_to_gpr(ctx, pattern5_1, expr1_0, &expr2_0)?;
11170                             let expr4_0 = constructor_do_ctz(ctx, expr0_0, pattern3_0, expr3_0)?;
11171                             let expr5_0 = constructor_output_gpr(ctx, expr4_0)?;
11172                             return Some(expr5_0);
11173                         }
11174                         &Opcode::Popcnt => {
11175                             // Rule at src/isa/x64/lower.isle line 1890.
11176                             let expr0_0: Type = I32;
11177                             let expr1_0: Type = I32;
11178                             let expr2_0 = ExtendKind::Zero;
11179                             let expr3_0 =
11180                                 constructor_extend_to_gpr(ctx, pattern5_1, expr1_0, &expr2_0)?;
11181                             let expr4_0 = constructor_do_popcnt(ctx, expr0_0, expr3_0)?;
11182                             let expr5_0 = constructor_output_gpr(ctx, expr4_0)?;
11183                             return Some(expr5_0);
11184                         }
11185                         _ => {}
11186                     }
11187                 }
11188                 _ => {}
11189             }
11190         }
11191         if let Some(pattern3_0) = C::ty_int_bool_ref_64(ctx, pattern2_0) {
11192             let pattern4_0 = C::inst_data(ctx, pattern0_0);
11193             if let &InstructionData::Load {
11194                 opcode: ref pattern5_0,
11195                 arg: pattern5_1,
11196                 flags: pattern5_2,
11197                 offset: pattern5_3,
11198             } = &pattern4_0
11199             {
11200                 if let &Opcode::Load = pattern5_0 {
11201                     // Rule at src/isa/x64/lower.isle line 2524.
11202                     let expr0_0 = constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
11203                     let expr1_0 = constructor_x64_mov(ctx, &expr0_0)?;
11204                     let expr2_0 = constructor_output_reg(ctx, expr1_0)?;
11205                     return Some(expr2_0);
11206                 }
11207             }
11208         }
11209         if let Some(pattern3_0) = C::ty_int_bool_128(ctx, pattern2_0) {
11210             let pattern4_0 = C::inst_data(ctx, pattern0_0);
11211             if let &InstructionData::Load {
11212                 opcode: ref pattern5_0,
11213                 arg: pattern5_1,
11214                 flags: pattern5_2,
11215                 offset: pattern5_3,
11216             } = &pattern4_0
11217             {
11218                 if let &Opcode::Load = pattern5_0 {
11219                     // Rule at src/isa/x64/lower.isle line 2558.
11220                     let expr0_0 = constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
11221                     let expr1_0: u32 = 8;
11222                     let expr2_0 = C::amode_offset(ctx, &expr0_0, expr1_0);
11223                     let expr3_0 = constructor_x64_mov(ctx, &expr0_0)?;
11224                     let expr4_0 = constructor_x64_mov(ctx, &expr2_0)?;
11225                     let expr5_0 = C::value_regs(ctx, expr3_0, expr4_0);
11226                     let expr6_0 = C::output(ctx, expr5_0);
11227                     return Some(expr6_0);
11228                 }
11229             }
11230         }
11231         if let Some(pattern3_0) = C::ty_vec128(ctx, pattern2_0) {
11232             let pattern4_0 = C::inst_data(ctx, pattern0_0);
11233             if let &InstructionData::Load {
11234                 opcode: ref pattern5_0,
11235                 arg: pattern5_1,
11236                 flags: pattern5_2,
11237                 offset: pattern5_3,
11238             } = &pattern4_0
11239             {
11240                 if let &Opcode::Load = pattern5_0 {
11241                     // Rule at src/isa/x64/lower.isle line 2554.
11242                     let expr0_0 = constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
11243                     let expr1_0 = constructor_amode_to_xmm_mem(ctx, &expr0_0)?;
11244                     let expr2_0 = constructor_x64_movdqu(ctx, &expr1_0)?;
11245                     let expr3_0 = constructor_output_xmm(ctx, expr2_0)?;
11246                     return Some(expr3_0);
11247                 }
11248             }
11249         }
11250         if let Some(pattern3_0) = C::is_gpr_type(ctx, pattern2_0) {
11251             let pattern4_0 = C::inst_data(ctx, pattern0_0);
11252             if let &InstructionData::Load {
11253                 opcode: ref pattern5_0,
11254                 arg: pattern5_1,
11255                 flags: pattern5_2,
11256                 offset: pattern5_3,
11257             } = &pattern4_0
11258             {
11259                 match pattern5_0 {
11260                     &Opcode::Uload8 => {
11261                         // Rule at src/isa/x64/lower.isle line 2529.
11262                         let expr0_0 = ExtMode::BQ;
11263                         let expr1_0 =
11264                             constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
11265                         let expr2_0 = constructor_amode_to_gpr_mem(ctx, &expr1_0)?;
11266                         let expr3_0 = constructor_x64_movzx(ctx, &expr0_0, &expr2_0)?;
11267                         let expr4_0 = constructor_output_gpr(ctx, expr3_0)?;
11268                         return Some(expr4_0);
11269                     }
11270                     &Opcode::Sload8 => {
11271                         // Rule at src/isa/x64/lower.isle line 2531.
11272                         let expr0_0 = ExtMode::BQ;
11273                         let expr1_0 =
11274                             constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
11275                         let expr2_0 = constructor_amode_to_gpr_mem(ctx, &expr1_0)?;
11276                         let expr3_0 = constructor_x64_movsx(ctx, &expr0_0, &expr2_0)?;
11277                         let expr4_0 = constructor_output_gpr(ctx, expr3_0)?;
11278                         return Some(expr4_0);
11279                     }
11280                     &Opcode::Uload16 => {
11281                         // Rule at src/isa/x64/lower.isle line 2533.
11282                         let expr0_0 = ExtMode::WQ;
11283                         let expr1_0 =
11284                             constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
11285                         let expr2_0 = constructor_amode_to_gpr_mem(ctx, &expr1_0)?;
11286                         let expr3_0 = constructor_x64_movzx(ctx, &expr0_0, &expr2_0)?;
11287                         let expr4_0 = constructor_output_gpr(ctx, expr3_0)?;
11288                         return Some(expr4_0);
11289                     }
11290                     &Opcode::Sload16 => {
11291                         // Rule at src/isa/x64/lower.isle line 2535.
11292                         let expr0_0 = ExtMode::WQ;
11293                         let expr1_0 =
11294                             constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
11295                         let expr2_0 = constructor_amode_to_gpr_mem(ctx, &expr1_0)?;
11296                         let expr3_0 = constructor_x64_movsx(ctx, &expr0_0, &expr2_0)?;
11297                         let expr4_0 = constructor_output_gpr(ctx, expr3_0)?;
11298                         return Some(expr4_0);
11299                     }
11300                     &Opcode::Uload32 => {
11301                         // Rule at src/isa/x64/lower.isle line 2537.
11302                         let expr0_0 = ExtMode::LQ;
11303                         let expr1_0 =
11304                             constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
11305                         let expr2_0 = constructor_amode_to_gpr_mem(ctx, &expr1_0)?;
11306                         let expr3_0 = constructor_x64_movzx(ctx, &expr0_0, &expr2_0)?;
11307                         let expr4_0 = constructor_output_gpr(ctx, expr3_0)?;
11308                         return Some(expr4_0);
11309                     }
11310                     &Opcode::Sload32 => {
11311                         // Rule at src/isa/x64/lower.isle line 2539.
11312                         let expr0_0 = ExtMode::LQ;
11313                         let expr1_0 =
11314                             constructor_to_amode(ctx, pattern5_2, pattern5_1, pattern5_3)?;
11315                         let expr2_0 = constructor_amode_to_gpr_mem(ctx, &expr1_0)?;
11316                         let expr3_0 = constructor_x64_movsx(ctx, &expr0_0, &expr2_0)?;
11317                         let expr4_0 = constructor_output_gpr(ctx, expr3_0)?;
11318                         return Some(expr4_0);
11319                     }
11320                     _ => {}
11321                 }
11322             }
11323         }
11324     }
11325     return None;
11326 }
11327 
11328 // Generated as internal constructor for term output_ifcout.
11329 pub fn constructor_output_ifcout<C: Context>(ctx: &mut C, arg0: Reg) -> Option<InstOutput> {
11330     let pattern0_0 = arg0;
11331     // Rule at src/isa/x64/lower.isle line 157.
11332     let expr0_0 = C::value_reg(ctx, pattern0_0);
11333     let expr1_0 = C::value_regs_invalid(ctx);
11334     let expr2_0 = C::output_pair(ctx, expr0_0, expr1_0);
11335     return Some(expr2_0);
11336 }
11337 
11338 // Generated as internal constructor for term sse_and.
11339 pub fn constructor_sse_and<C: Context>(
11340     ctx: &mut C,
11341     arg0: Type,
11342     arg1: Xmm,
11343     arg2: &XmmMem,
11344 ) -> Option<Xmm> {
11345     let pattern0_0 = arg0;
11346     if pattern0_0 == F32X4 {
11347         let pattern2_0 = arg1;
11348         let pattern3_0 = arg2;
11349         // Rule at src/isa/x64/lower.isle line 324.
11350         let expr0_0 = constructor_x64_andps(ctx, pattern2_0, pattern3_0)?;
11351         return Some(expr0_0);
11352     }
11353     if pattern0_0 == F64X2 {
11354         let pattern2_0 = arg1;
11355         let pattern3_0 = arg2;
11356         // Rule at src/isa/x64/lower.isle line 325.
11357         let expr0_0 = constructor_x64_andpd(ctx, pattern2_0, pattern3_0)?;
11358         return Some(expr0_0);
11359     }
11360     if let Some((pattern1_0, pattern1_1)) = C::multi_lane(ctx, pattern0_0) {
11361         let pattern2_0 = arg1;
11362         let pattern3_0 = arg2;
11363         // Rule at src/isa/x64/lower.isle line 326.
11364         let expr0_0 = constructor_x64_pand(ctx, pattern2_0, pattern3_0)?;
11365         return Some(expr0_0);
11366     }
11367     return None;
11368 }
11369 
11370 // Generated as internal constructor for term sse_or.
11371 pub fn constructor_sse_or<C: Context>(
11372     ctx: &mut C,
11373     arg0: Type,
11374     arg1: Xmm,
11375     arg2: &XmmMem,
11376 ) -> Option<Xmm> {
11377     let pattern0_0 = arg0;
11378     if pattern0_0 == F32X4 {
11379         let pattern2_0 = arg1;
11380         let pattern3_0 = arg2;
11381         // Rule at src/isa/x64/lower.isle line 388.
11382         let expr0_0 = constructor_x64_orps(ctx, pattern2_0, pattern3_0)?;
11383         return Some(expr0_0);
11384     }
11385     if pattern0_0 == F64X2 {
11386         let pattern2_0 = arg1;
11387         let pattern3_0 = arg2;
11388         // Rule at src/isa/x64/lower.isle line 389.
11389         let expr0_0 = constructor_x64_orpd(ctx, pattern2_0, pattern3_0)?;
11390         return Some(expr0_0);
11391     }
11392     if let Some((pattern1_0, pattern1_1)) = C::multi_lane(ctx, pattern0_0) {
11393         let pattern2_0 = arg1;
11394         let pattern3_0 = arg2;
11395         // Rule at src/isa/x64/lower.isle line 390.
11396         let expr0_0 = constructor_x64_por(ctx, pattern2_0, pattern3_0)?;
11397         return Some(expr0_0);
11398     }
11399     return None;
11400 }
11401 
11402 // Generated as internal constructor for term or_i128.
11403 pub fn constructor_or_i128<C: Context>(
11404     ctx: &mut C,
11405     arg0: ValueRegs,
11406     arg1: ValueRegs,
11407 ) -> Option<ValueRegs> {
11408     let pattern0_0 = arg0;
11409     let pattern1_0 = arg1;
11410     // Rule at src/isa/x64/lower.isle line 399.
11411     let expr0_0: usize = 0;
11412     let expr1_0 = constructor_value_regs_get_gpr(ctx, pattern0_0, expr0_0)?;
11413     let expr2_0: usize = 1;
11414     let expr3_0 = constructor_value_regs_get_gpr(ctx, pattern0_0, expr2_0)?;
11415     let expr4_0: usize = 0;
11416     let expr5_0 = constructor_value_regs_get_gpr(ctx, pattern1_0, expr4_0)?;
11417     let expr6_0: usize = 1;
11418     let expr7_0 = constructor_value_regs_get_gpr(ctx, pattern1_0, expr6_0)?;
11419     let expr8_0: Type = I64;
11420     let expr9_0 = C::gpr_to_gpr_mem_imm(ctx, expr5_0);
11421     let expr10_0 = constructor_x64_or(ctx, expr8_0, expr1_0, &expr9_0)?;
11422     let expr11_0: Type = I64;
11423     let expr12_0 = C::gpr_to_gpr_mem_imm(ctx, expr7_0);
11424     let expr13_0 = constructor_x64_or(ctx, expr11_0, expr3_0, &expr12_0)?;
11425     let expr14_0 = constructor_value_gprs(ctx, expr10_0, expr13_0)?;
11426     return Some(expr14_0);
11427 }
11428 
11429 // Generated as internal constructor for term shl_i128.
11430 pub fn constructor_shl_i128<C: Context>(
11431     ctx: &mut C,
11432     arg0: ValueRegs,
11433     arg1: Gpr,
11434 ) -> Option<ValueRegs> {
11435     let pattern0_0 = arg0;
11436     let pattern1_0 = arg1;
11437     // Rule at src/isa/x64/lower.isle line 489.
11438     let expr0_0: usize = 0;
11439     let expr1_0 = constructor_value_regs_get_gpr(ctx, pattern0_0, expr0_0)?;
11440     let expr2_0: usize = 1;
11441     let expr3_0 = constructor_value_regs_get_gpr(ctx, pattern0_0, expr2_0)?;
11442     let expr4_0: Type = I64;
11443     let expr5_0 = C::gpr_to_imm8_gpr(ctx, pattern1_0);
11444     let expr6_0 = constructor_x64_shl(ctx, expr4_0, expr1_0, &expr5_0)?;
11445     let expr7_0: Type = I64;
11446     let expr8_0 = C::gpr_to_imm8_gpr(ctx, pattern1_0);
11447     let expr9_0 = constructor_x64_shl(ctx, expr7_0, expr3_0, &expr8_0)?;
11448     let expr10_0: Type = I64;
11449     let expr11_0: Type = I64;
11450     let expr12_0: Type = I64;
11451     let expr13_0: u64 = 64;
11452     let expr14_0 = constructor_imm(ctx, expr12_0, expr13_0)?;
11453     let expr15_0 = C::gpr_new(ctx, expr14_0);
11454     let expr16_0 = C::gpr_to_gpr_mem_imm(ctx, pattern1_0);
11455     let expr17_0 = constructor_x64_sub(ctx, expr11_0, expr15_0, &expr16_0)?;
11456     let expr18_0 = C::gpr_to_imm8_gpr(ctx, expr17_0);
11457     let expr19_0 = constructor_x64_shr(ctx, expr10_0, expr1_0, &expr18_0)?;
11458     let expr20_0: Type = I64;
11459     let expr21_0: u64 = 0;
11460     let expr22_0 = constructor_imm(ctx, expr20_0, expr21_0)?;
11461     let expr23_0 = C::gpr_new(ctx, expr22_0);
11462     let expr24_0 = OperandSize::Size64;
11463     let expr25_0: u32 = 127;
11464     let expr26_0 = RegMemImm::Imm { simm32: expr25_0 };
11465     let expr27_0 = C::gpr_mem_imm_new(ctx, &expr26_0);
11466     let expr28_0 = constructor_x64_test(ctx, &expr24_0, &expr27_0, pattern1_0)?;
11467     let expr29_0: Type = I64;
11468     let expr30_0 = CC::Z;
11469     let expr31_0 = C::gpr_to_gpr_mem(ctx, expr23_0);
11470     let expr32_0 = constructor_cmove(ctx, expr29_0, &expr30_0, &expr31_0, expr19_0)?;
11471     let expr33_0 = constructor_with_flags_reg(ctx, &expr28_0, &expr32_0)?;
11472     let expr34_0 = C::gpr_new(ctx, expr33_0);
11473     let expr35_0: Type = I64;
11474     let expr36_0 = C::gpr_to_gpr_mem_imm(ctx, expr9_0);
11475     let expr37_0 = constructor_x64_or(ctx, expr35_0, expr34_0, &expr36_0)?;
11476     let expr38_0 = OperandSize::Size64;
11477     let expr39_0: u32 = 64;
11478     let expr40_0 = RegMemImm::Imm { simm32: expr39_0 };
11479     let expr41_0 = C::gpr_mem_imm_new(ctx, &expr40_0);
11480     let expr42_0 = constructor_x64_test(ctx, &expr38_0, &expr41_0, pattern1_0)?;
11481     let expr43_0: Type = I64;
11482     let expr44_0 = CC::Z;
11483     let expr45_0 = C::gpr_to_gpr_mem(ctx, expr6_0);
11484     let expr46_0 = constructor_cmove(ctx, expr43_0, &expr44_0, &expr45_0, expr23_0)?;
11485     let expr47_0: Type = I64;
11486     let expr48_0 = CC::Z;
11487     let expr49_0 = C::gpr_to_gpr_mem(ctx, expr37_0);
11488     let expr50_0 = constructor_cmove(ctx, expr47_0, &expr48_0, &expr49_0, expr6_0)?;
11489     let expr51_0 = constructor_consumes_flags_concat(ctx, &expr46_0, &expr50_0)?;
11490     let expr52_0 = constructor_with_flags(ctx, &expr42_0, &expr51_0)?;
11491     return Some(expr52_0);
11492 }
11493 
11494 // Generated as internal constructor for term ishl_i8x16_mask.
11495 pub fn constructor_ishl_i8x16_mask<C: Context>(
11496     ctx: &mut C,
11497     arg0: &RegMemImm,
11498 ) -> Option<SyntheticAmode> {
11499     let pattern0_0 = arg0;
11500     match pattern0_0 {
11501         &RegMemImm::Imm { simm32: pattern1_0 } => {
11502             // Rule at src/isa/x64/lower.isle line 552.
11503             let expr0_0 = C::ishl_i8x16_mask_for_const(ctx, pattern1_0);
11504             return Some(expr0_0);
11505         }
11506         &RegMemImm::Reg { reg: pattern1_0 } => {
11507             // Rule at src/isa/x64/lower.isle line 561.
11508             let expr0_0 = C::ishl_i8x16_mask_table(ctx);
11509             let expr1_0 = constructor_x64_lea(ctx, &expr0_0)?;
11510             let expr2_0: Type = I64;
11511             let expr3_0 = C::gpr_new(ctx, pattern1_0);
11512             let expr4_0: u8 = 4;
11513             let expr5_0 = C::imm8_to_imm8_gpr(ctx, expr4_0);
11514             let expr6_0 = constructor_x64_shl(ctx, expr2_0, expr3_0, &expr5_0)?;
11515             let expr7_0: u32 = 0;
11516             let expr8_0: u8 = 0;
11517             let expr9_0 = C::amode_imm_reg_reg_shift(ctx, expr7_0, expr1_0, expr6_0, expr8_0);
11518             let expr10_0 = C::amode_to_synthetic_amode(ctx, &expr9_0);
11519             return Some(expr10_0);
11520         }
11521         &RegMemImm::Mem {
11522             addr: ref pattern1_0,
11523         } => {
11524             // Rule at src/isa/x64/lower.isle line 571.
11525             let expr0_0: Type = I64;
11526             let expr1_0 = ExtKind::None;
11527             let expr2_0 = constructor_x64_load(ctx, expr0_0, pattern1_0, &expr1_0)?;
11528             let expr3_0 = RegMemImm::Reg { reg: expr2_0 };
11529             let expr4_0 = constructor_ishl_i8x16_mask(ctx, &expr3_0)?;
11530             return Some(expr4_0);
11531         }
11532         _ => {}
11533     }
11534     return None;
11535 }
11536 
11537 // Generated as internal constructor for term shr_i128.
11538 pub fn constructor_shr_i128<C: Context>(
11539     ctx: &mut C,
11540     arg0: ValueRegs,
11541     arg1: Gpr,
11542 ) -> Option<ValueRegs> {
11543     let pattern0_0 = arg0;
11544     let pattern1_0 = arg1;
11545     // Rule at src/isa/x64/lower.isle line 596.
11546     let expr0_0: usize = 0;
11547     let expr1_0 = constructor_value_regs_get_gpr(ctx, pattern0_0, expr0_0)?;
11548     let expr2_0: usize = 1;
11549     let expr3_0 = constructor_value_regs_get_gpr(ctx, pattern0_0, expr2_0)?;
11550     let expr4_0: Type = I64;
11551     let expr5_0 = C::gpr_to_imm8_gpr(ctx, pattern1_0);
11552     let expr6_0 = constructor_x64_shr(ctx, expr4_0, expr1_0, &expr5_0)?;
11553     let expr7_0: Type = I64;
11554     let expr8_0 = C::gpr_to_imm8_gpr(ctx, pattern1_0);
11555     let expr9_0 = constructor_x64_shr(ctx, expr7_0, expr3_0, &expr8_0)?;
11556     let expr10_0: Type = I64;
11557     let expr11_0: Type = I64;
11558     let expr12_0: Type = I64;
11559     let expr13_0: u64 = 64;
11560     let expr14_0 = constructor_imm(ctx, expr12_0, expr13_0)?;
11561     let expr15_0 = C::gpr_new(ctx, expr14_0);
11562     let expr16_0 = C::gpr_to_gpr_mem_imm(ctx, pattern1_0);
11563     let expr17_0 = constructor_x64_sub(ctx, expr11_0, expr15_0, &expr16_0)?;
11564     let expr18_0 = C::gpr_to_imm8_gpr(ctx, expr17_0);
11565     let expr19_0 = constructor_x64_shl(ctx, expr10_0, expr3_0, &expr18_0)?;
11566     let expr20_0 = OperandSize::Size64;
11567     let expr21_0: u32 = 127;
11568     let expr22_0 = RegMemImm::Imm { simm32: expr21_0 };
11569     let expr23_0 = C::gpr_mem_imm_new(ctx, &expr22_0);
11570     let expr24_0 = constructor_x64_test(ctx, &expr20_0, &expr23_0, pattern1_0)?;
11571     let expr25_0: Type = I64;
11572     let expr26_0 = CC::Z;
11573     let expr27_0: Type = I64;
11574     let expr28_0: u64 = 0;
11575     let expr29_0 = constructor_imm(ctx, expr27_0, expr28_0)?;
11576     let expr30_0 = C::reg_to_gpr_mem(ctx, expr29_0);
11577     let expr31_0 = constructor_cmove(ctx, expr25_0, &expr26_0, &expr30_0, expr19_0)?;
11578     let expr32_0 = constructor_with_flags_reg(ctx, &expr24_0, &expr31_0)?;
11579     let expr33_0 = C::gpr_new(ctx, expr32_0);
11580     let expr34_0: Type = I64;
11581     let expr35_0 = C::gpr_to_gpr_mem_imm(ctx, expr6_0);
11582     let expr36_0 = constructor_x64_or(ctx, expr34_0, expr33_0, &expr35_0)?;
11583     let expr37_0 = OperandSize::Size64;
11584     let expr38_0: u32 = 64;
11585     let expr39_0 = RegMemImm::Imm { simm32: expr38_0 };
11586     let expr40_0 = C::gpr_mem_imm_new(ctx, &expr39_0);
11587     let expr41_0 = constructor_x64_test(ctx, &expr37_0, &expr40_0, pattern1_0)?;
11588     let expr42_0: Type = I64;
11589     let expr43_0 = CC::Z;
11590     let expr44_0 = C::gpr_to_gpr_mem(ctx, expr36_0);
11591     let expr45_0 = constructor_cmove(ctx, expr42_0, &expr43_0, &expr44_0, expr9_0)?;
11592     let expr46_0: Type = I64;
11593     let expr47_0 = CC::Z;
11594     let expr48_0 = C::gpr_to_gpr_mem(ctx, expr9_0);
11595     let expr49_0: Type = I64;
11596     let expr50_0: u64 = 0;
11597     let expr51_0 = constructor_imm(ctx, expr49_0, expr50_0)?;
11598     let expr52_0 = C::gpr_new(ctx, expr51_0);
11599     let expr53_0 = constructor_cmove(ctx, expr46_0, &expr47_0, &expr48_0, expr52_0)?;
11600     let expr54_0 = constructor_consumes_flags_concat(ctx, &expr45_0, &expr53_0)?;
11601     let expr55_0 = constructor_with_flags(ctx, &expr41_0, &expr54_0)?;
11602     return Some(expr55_0);
11603 }
11604 
11605 // Generated as internal constructor for term ushr_i8x16_mask.
11606 pub fn constructor_ushr_i8x16_mask<C: Context>(
11607     ctx: &mut C,
11608     arg0: &RegMemImm,
11609 ) -> Option<SyntheticAmode> {
11610     let pattern0_0 = arg0;
11611     match pattern0_0 {
11612         &RegMemImm::Imm { simm32: pattern1_0 } => {
11613             // Rule at src/isa/x64/lower.isle line 653.
11614             let expr0_0 = C::ushr_i8x16_mask_for_const(ctx, pattern1_0);
11615             return Some(expr0_0);
11616         }
11617         &RegMemImm::Reg { reg: pattern1_0 } => {
11618             // Rule at src/isa/x64/lower.isle line 662.
11619             let expr0_0 = C::ushr_i8x16_mask_table(ctx);
11620             let expr1_0 = constructor_x64_lea(ctx, &expr0_0)?;
11621             let expr2_0: Type = I64;
11622             let expr3_0 = C::gpr_new(ctx, pattern1_0);
11623             let expr4_0: u8 = 4;
11624             let expr5_0 = C::imm8_to_imm8_gpr(ctx, expr4_0);
11625             let expr6_0 = constructor_x64_shl(ctx, expr2_0, expr3_0, &expr5_0)?;
11626             let expr7_0: u32 = 0;
11627             let expr8_0: u8 = 0;
11628             let expr9_0 = C::amode_imm_reg_reg_shift(ctx, expr7_0, expr1_0, expr6_0, expr8_0);
11629             let expr10_0 = C::amode_to_synthetic_amode(ctx, &expr9_0);
11630             return Some(expr10_0);
11631         }
11632         &RegMemImm::Mem {
11633             addr: ref pattern1_0,
11634         } => {
11635             // Rule at src/isa/x64/lower.isle line 673.
11636             let expr0_0: Type = I64;
11637             let expr1_0 = ExtKind::None;
11638             let expr2_0 = constructor_x64_load(ctx, expr0_0, pattern1_0, &expr1_0)?;
11639             let expr3_0 = RegMemImm::Reg { reg: expr2_0 };
11640             let expr4_0 = constructor_ushr_i8x16_mask(ctx, &expr3_0)?;
11641             return Some(expr4_0);
11642         }
11643         _ => {}
11644     }
11645     return None;
11646 }
11647 
11648 // Generated as internal constructor for term sar_i128.
11649 pub fn constructor_sar_i128<C: Context>(
11650     ctx: &mut C,
11651     arg0: ValueRegs,
11652     arg1: Gpr,
11653 ) -> Option<ValueRegs> {
11654     let pattern0_0 = arg0;
11655     let pattern1_0 = arg1;
11656     // Rule at src/isa/x64/lower.isle line 698.
11657     let expr0_0: usize = 0;
11658     let expr1_0 = constructor_value_regs_get_gpr(ctx, pattern0_0, expr0_0)?;
11659     let expr2_0: usize = 1;
11660     let expr3_0 = constructor_value_regs_get_gpr(ctx, pattern0_0, expr2_0)?;
11661     let expr4_0: Type = I64;
11662     let expr5_0 = C::gpr_to_imm8_gpr(ctx, pattern1_0);
11663     let expr6_0 = constructor_x64_shr(ctx, expr4_0, expr1_0, &expr5_0)?;
11664     let expr7_0: Type = I64;
11665     let expr8_0 = C::gpr_to_imm8_gpr(ctx, pattern1_0);
11666     let expr9_0 = constructor_x64_sar(ctx, expr7_0, expr3_0, &expr8_0)?;
11667     let expr10_0: Type = I64;
11668     let expr11_0: Type = I64;
11669     let expr12_0: Type = I64;
11670     let expr13_0: u64 = 64;
11671     let expr14_0 = constructor_imm(ctx, expr12_0, expr13_0)?;
11672     let expr15_0 = C::gpr_new(ctx, expr14_0);
11673     let expr16_0 = C::gpr_to_gpr_mem_imm(ctx, pattern1_0);
11674     let expr17_0 = constructor_x64_sub(ctx, expr11_0, expr15_0, &expr16_0)?;
11675     let expr18_0 = C::gpr_to_imm8_gpr(ctx, expr17_0);
11676     let expr19_0 = constructor_x64_shl(ctx, expr10_0, expr3_0, &expr18_0)?;
11677     let expr20_0 = OperandSize::Size64;
11678     let expr21_0: u32 = 127;
11679     let expr22_0 = RegMemImm::Imm { simm32: expr21_0 };
11680     let expr23_0 = C::gpr_mem_imm_new(ctx, &expr22_0);
11681     let expr24_0 = constructor_x64_test(ctx, &expr20_0, &expr23_0, pattern1_0)?;
11682     let expr25_0: Type = I64;
11683     let expr26_0 = CC::Z;
11684     let expr27_0: Type = I64;
11685     let expr28_0: u64 = 0;
11686     let expr29_0 = constructor_imm(ctx, expr27_0, expr28_0)?;
11687     let expr30_0 = C::reg_to_gpr_mem(ctx, expr29_0);
11688     let expr31_0 = constructor_cmove(ctx, expr25_0, &expr26_0, &expr30_0, expr19_0)?;
11689     let expr32_0 = constructor_with_flags_reg(ctx, &expr24_0, &expr31_0)?;
11690     let expr33_0 = C::gpr_new(ctx, expr32_0);
11691     let expr34_0: Type = I64;
11692     let expr35_0 = C::gpr_to_gpr_mem_imm(ctx, expr33_0);
11693     let expr36_0 = constructor_x64_or(ctx, expr34_0, expr6_0, &expr35_0)?;
11694     let expr37_0: Type = I64;
11695     let expr38_0: u8 = 63;
11696     let expr39_0 = C::imm8_to_imm8_gpr(ctx, expr38_0);
11697     let expr40_0 = constructor_x64_sar(ctx, expr37_0, expr3_0, &expr39_0)?;
11698     let expr41_0 = OperandSize::Size64;
11699     let expr42_0: u32 = 64;
11700     let expr43_0 = RegMemImm::Imm { simm32: expr42_0 };
11701     let expr44_0 = C::gpr_mem_imm_new(ctx, &expr43_0);
11702     let expr45_0 = constructor_x64_test(ctx, &expr41_0, &expr44_0, pattern1_0)?;
11703     let expr46_0: Type = I64;
11704     let expr47_0 = CC::Z;
11705     let expr48_0 = C::gpr_to_gpr_mem(ctx, expr36_0);
11706     let expr49_0 = constructor_cmove(ctx, expr46_0, &expr47_0, &expr48_0, expr9_0)?;
11707     let expr50_0: Type = I64;
11708     let expr51_0 = CC::Z;
11709     let expr52_0 = C::gpr_to_gpr_mem(ctx, expr9_0);
11710     let expr53_0 = constructor_cmove(ctx, expr50_0, &expr51_0, &expr52_0, expr40_0)?;
11711     let expr54_0 = constructor_consumes_flags_concat(ctx, &expr49_0, &expr53_0)?;
11712     let expr55_0 = constructor_with_flags(ctx, &expr45_0, &expr54_0)?;
11713     return Some(expr55_0);
11714 }
11715 
11716 // Generated as internal constructor for term sshr_i8x16_bigger_shift.
11717 pub fn constructor_sshr_i8x16_bigger_shift<C: Context>(
11718     ctx: &mut C,
11719     arg0: Type,
11720     arg1: &RegMemImm,
11721 ) -> Option<XmmMemImm> {
11722     let pattern0_0 = arg0;
11723     let pattern1_0 = arg1;
11724     match pattern1_0 {
11725         &RegMemImm::Imm { simm32: pattern2_0 } => {
11726             // Rule at src/isa/x64/lower.isle line 762.
11727             let expr0_0: u32 = 8;
11728             let expr1_0 = C::u32_add(ctx, pattern2_0, expr0_0);
11729             let expr2_0 = RegMemImm::Imm { simm32: expr1_0 };
11730             let expr3_0 = C::xmm_mem_imm_new(ctx, &expr2_0);
11731             return Some(expr3_0);
11732         }
11733         &RegMemImm::Reg { reg: pattern2_0 } => {
11734             // Rule at src/isa/x64/lower.isle line 764.
11735             let expr0_0 = C::gpr_new(ctx, pattern2_0);
11736             let expr1_0: u32 = 8;
11737             let expr2_0 = RegMemImm::Imm { simm32: expr1_0 };
11738             let expr3_0 = C::gpr_mem_imm_new(ctx, &expr2_0);
11739             let expr4_0 = constructor_x64_add(ctx, pattern0_0, expr0_0, &expr3_0)?;
11740             let expr5_0 = C::gpr_to_reg(ctx, expr4_0);
11741             let expr6_0 = RegMemImm::Reg { reg: expr5_0 };
11742             let expr7_0 = constructor_mov_rmi_to_xmm(ctx, &expr6_0)?;
11743             return Some(expr7_0);
11744         }
11745         &RegMemImm::Mem {
11746             addr: ref pattern2_0,
11747         } => {
11748             // Rule at src/isa/x64/lower.isle line 768.
11749             let expr0_0: u64 = 8;
11750             let expr1_0 = constructor_imm(ctx, pattern0_0, expr0_0)?;
11751             let expr2_0 = C::gpr_new(ctx, expr1_0);
11752             let expr3_0 = C::gpr_mem_imm_new(ctx, pattern1_0);
11753             let expr4_0 = constructor_x64_add(ctx, pattern0_0, expr2_0, &expr3_0)?;
11754             let expr5_0 = C::gpr_to_reg(ctx, expr4_0);
11755             let expr6_0 = RegMemImm::Reg { reg: expr5_0 };
11756             let expr7_0 = constructor_mov_rmi_to_xmm(ctx, &expr6_0)?;
11757             return Some(expr7_0);
11758         }
11759         _ => {}
11760     }
11761     return None;
11762 }
11763 
11764 // Generated as internal constructor for term sse_and_not.
11765 pub fn constructor_sse_and_not<C: Context>(
11766     ctx: &mut C,
11767     arg0: Type,
11768     arg1: Xmm,
11769     arg2: &XmmMem,
11770 ) -> Option<Xmm> {
11771     let pattern0_0 = arg0;
11772     if pattern0_0 == F32X4 {
11773         let pattern2_0 = arg1;
11774         let pattern3_0 = arg2;
11775         // Rule at src/isa/x64/lower.isle line 1194.
11776         let expr0_0 = constructor_x64_andnps(ctx, pattern2_0, pattern3_0)?;
11777         return Some(expr0_0);
11778     }
11779     if pattern0_0 == F64X2 {
11780         let pattern2_0 = arg1;
11781         let pattern3_0 = arg2;
11782         // Rule at src/isa/x64/lower.isle line 1195.
11783         let expr0_0 = constructor_x64_andnpd(ctx, pattern2_0, pattern3_0)?;
11784         return Some(expr0_0);
11785     }
11786     if let Some((pattern1_0, pattern1_1)) = C::multi_lane(ctx, pattern0_0) {
11787         let pattern2_0 = arg1;
11788         let pattern3_0 = arg2;
11789         // Rule at src/isa/x64/lower.isle line 1196.
11790         let expr0_0 = constructor_x64_pandn(ctx, pattern2_0, pattern3_0)?;
11791         return Some(expr0_0);
11792     }
11793     return None;
11794 }
11795 
11796 // Generated as internal constructor for term i128_not.
11797 pub fn constructor_i128_not<C: Context>(ctx: &mut C, arg0: Value) -> Option<ValueRegs> {
11798     let pattern0_0 = arg0;
11799     // Rule at src/isa/x64/lower.isle line 1259.
11800     let expr0_0 = C::put_in_regs(ctx, pattern0_0);
11801     let expr1_0: usize = 0;
11802     let expr2_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr1_0)?;
11803     let expr3_0: usize = 1;
11804     let expr4_0 = constructor_value_regs_get_gpr(ctx, expr0_0, expr3_0)?;
11805     let expr5_0: Type = I64;
11806     let expr6_0 = constructor_x64_not(ctx, expr5_0, expr2_0)?;
11807     let expr7_0: Type = I64;
11808     let expr8_0 = constructor_x64_not(ctx, expr7_0, expr4_0)?;
11809     let expr9_0 = constructor_value_gprs(ctx, expr6_0, expr8_0)?;
11810     return Some(expr9_0);
11811 }
11812 
11813 // Generated as internal constructor for term vec_insert_lane.
11814 pub fn constructor_vec_insert_lane<C: Context>(
11815     ctx: &mut C,
11816     arg0: Type,
11817     arg1: Xmm,
11818     arg2: &RegMem,
11819     arg3: u8,
11820 ) -> Option<Xmm> {
11821     let pattern0_0 = arg0;
11822     if pattern0_0 == I8X16 {
11823         let pattern2_0 = arg1;
11824         let pattern3_0 = arg2;
11825         let pattern4_0 = arg3;
11826         // Rule at src/isa/x64/lower.isle line 1313.
11827         let expr0_0 = C::reg_mem_to_gpr_mem(ctx, pattern3_0);
11828         let expr1_0 = constructor_x64_pinsrb(ctx, pattern2_0, &expr0_0, pattern4_0)?;
11829         return Some(expr1_0);
11830     }
11831     if pattern0_0 == I16X8 {
11832         let pattern2_0 = arg1;
11833         let pattern3_0 = arg2;
11834         let pattern4_0 = arg3;
11835         // Rule at src/isa/x64/lower.isle line 1317.
11836         let expr0_0 = C::reg_mem_to_gpr_mem(ctx, pattern3_0);
11837         let expr1_0 = constructor_x64_pinsrw(ctx, pattern2_0, &expr0_0, pattern4_0)?;
11838         return Some(expr1_0);
11839     }
11840     if pattern0_0 == I32X4 {
11841         let pattern2_0 = arg1;
11842         let pattern3_0 = arg2;
11843         let pattern4_0 = arg3;
11844         // Rule at src/isa/x64/lower.isle line 1321.
11845         let expr0_0 = C::reg_mem_to_gpr_mem(ctx, pattern3_0);
11846         let expr1_0 = OperandSize::Size32;
11847         let expr2_0 = constructor_x64_pinsrd(ctx, pattern2_0, &expr0_0, pattern4_0, &expr1_0)?;
11848         return Some(expr2_0);
11849     }
11850     if pattern0_0 == I64X2 {
11851         let pattern2_0 = arg1;
11852         let pattern3_0 = arg2;
11853         let pattern4_0 = arg3;
11854         // Rule at src/isa/x64/lower.isle line 1325.
11855         let expr0_0 = C::reg_mem_to_gpr_mem(ctx, pattern3_0);
11856         let expr1_0 = OperandSize::Size64;
11857         let expr2_0 = constructor_x64_pinsrd(ctx, pattern2_0, &expr0_0, pattern4_0, &expr1_0)?;
11858         return Some(expr2_0);
11859     }
11860     if pattern0_0 == F32X4 {
11861         let pattern2_0 = arg1;
11862         let pattern3_0 = arg2;
11863         let pattern4_0 = arg3;
11864         // Rule at src/isa/x64/lower.isle line 1329.
11865         let expr0_0 = C::reg_mem_to_xmm_mem(ctx, pattern3_0);
11866         let expr1_0 = C::sse_insertps_lane_imm(ctx, pattern4_0);
11867         let expr2_0 = constructor_x64_insertps(ctx, pattern2_0, &expr0_0, expr1_0)?;
11868         return Some(expr2_0);
11869     }
11870     if pattern0_0 == F64X2 {
11871         let pattern2_0 = arg1;
11872         let pattern3_0 = arg2;
11873         if let &RegMem::Reg { reg: pattern4_0 } = pattern3_0 {
11874             let pattern5_0 = arg3;
11875             if pattern5_0 == 0 {
11876                 // Rule at src/isa/x64/lower.isle line 1351.
11877                 let expr0_0 = constructor_reg_to_xmm_mem(ctx, pattern4_0)?;
11878                 let expr1_0 = constructor_x64_movsd_regmove(ctx, pattern2_0, &expr0_0)?;
11879                 return Some(expr1_0);
11880             }
11881         }
11882         let pattern4_0 = arg3;
11883         if pattern4_0 == 0 {
11884             // Rule at src/isa/x64/lower.isle line 1353.
11885             let expr0_0 = C::reg_mem_to_xmm_mem(ctx, pattern3_0);
11886             let expr1_0 = constructor_x64_movsd_load(ctx, &expr0_0)?;
11887             let expr2_0 = C::xmm_to_xmm_mem(ctx, expr1_0);
11888             let expr3_0 = constructor_x64_movsd_regmove(ctx, pattern2_0, &expr2_0)?;
11889             return Some(expr3_0);
11890         }
11891         if pattern4_0 == 1 {
11892             // Rule at src/isa/x64/lower.isle line 1361.
11893             let expr0_0 = C::reg_mem_to_xmm_mem(ctx, pattern3_0);
11894             let expr1_0 = constructor_x64_movlhps(ctx, pattern2_0, &expr0_0)?;
11895             return Some(expr1_0);
11896         }
11897     }
11898     return None;
11899 }
11900 
11901 // Generated as internal constructor for term cmp_and_choose.
11902 pub fn constructor_cmp_and_choose<C: Context>(
11903     ctx: &mut C,
11904     arg0: Type,
11905     arg1: &CC,
11906     arg2: Value,
11907     arg3: Value,
11908 ) -> Option<ValueRegs> {
11909     let pattern0_0 = arg0;
11910     if let Some(pattern1_0) = C::fits_in_64(ctx, pattern0_0) {
11911         let pattern2_0 = arg1;
11912         let pattern3_0 = arg2;
11913         let pattern4_0 = arg3;
11914         // Rule at src/isa/x64/lower.isle line 1369.
11915         let expr0_0 = C::raw_operand_size_of_type(ctx, pattern1_0);
11916         let expr1_0 = C::put_in_reg(ctx, pattern3_0);
11917         let expr2_0 = C::put_in_reg(ctx, pattern4_0);
11918         let expr3_0 = constructor_reg_to_gpr_mem_imm(ctx, expr1_0)?;
11919         let expr4_0 = C::gpr_new(ctx, expr2_0);
11920         let expr5_0 = constructor_x64_cmp(ctx, &expr0_0, &expr3_0, expr4_0)?;
11921         let expr6_0 = C::reg_to_gpr_mem(ctx, expr2_0);
11922         let expr7_0 = C::gpr_new(ctx, expr1_0);
11923         let expr8_0 = constructor_cmove(ctx, pattern1_0, pattern2_0, &expr6_0, expr7_0)?;
11924         let expr9_0 = constructor_with_flags_reg(ctx, &expr5_0, &expr8_0)?;
11925         let expr10_0 = C::value_reg(ctx, expr9_0);
11926         return Some(expr10_0);
11927     }
11928     return None;
11929 }
11930 
11931 // Generated as internal constructor for term do_clz.
11932 pub fn constructor_do_clz<C: Context>(
11933     ctx: &mut C,
11934     arg0: Type,
11935     arg1: Type,
11936     arg2: Gpr,
11937 ) -> Option<Gpr> {
11938     let pattern0_0 = arg0;
11939     let pattern1_0 = arg1;
11940     let pattern2_0 = arg2;
11941     // Rule at src/isa/x64/lower.isle line 1816.
11942     let expr0_0: Type = I64;
11943     let expr1_0: i64 = -1;
11944     let expr2_0 = constructor_imm_i64(ctx, expr0_0, expr1_0)?;
11945     let expr3_0 = C::gpr_new(ctx, expr2_0);
11946     let expr4_0 = constructor_bsr_or_else(ctx, pattern0_0, pattern2_0, expr3_0)?;
11947     let expr5_0 = C::gpr_to_reg(ctx, expr4_0);
11948     let expr6_0 = C::ty_bits_u64(ctx, pattern1_0);
11949     let expr7_0: u64 = 1;
11950     let expr8_0 = C::u64_sub(ctx, expr6_0, expr7_0)?;
11951     let expr9_0 = constructor_imm(ctx, pattern0_0, expr8_0)?;
11952     let expr10_0 = C::gpr_new(ctx, expr9_0);
11953     let expr11_0 = constructor_reg_to_gpr_mem_imm(ctx, expr5_0)?;
11954     let expr12_0 = constructor_x64_sub(ctx, pattern0_0, expr10_0, &expr11_0)?;
11955     return Some(expr12_0);
11956 }
11957 
11958 // Generated as internal constructor for term do_ctz.
11959 pub fn constructor_do_ctz<C: Context>(
11960     ctx: &mut C,
11961     arg0: Type,
11962     arg1: Type,
11963     arg2: Gpr,
11964 ) -> Option<Gpr> {
11965     let pattern0_0 = arg0;
11966     let pattern1_0 = arg1;
11967     let pattern2_0 = arg2;
11968     // Rule at src/isa/x64/lower.isle line 1857.
11969     let expr0_0: Type = I64;
11970     let expr1_0 = C::ty_bits_u64(ctx, pattern1_0);
11971     let expr2_0 = constructor_imm(ctx, expr0_0, expr1_0)?;
11972     let expr3_0 = C::gpr_new(ctx, expr2_0);
11973     let expr4_0 = constructor_bsf_or_else(ctx, pattern0_0, pattern2_0, expr3_0)?;
11974     return Some(expr4_0);
11975 }
11976 
11977 // Generated as internal constructor for term do_popcnt.
11978 pub fn constructor_do_popcnt<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Option<Gpr> {
11979     let pattern0_0 = arg0;
11980     if pattern0_0 == I32 {
11981         let pattern2_0 = arg1;
11982         // Rule at src/isa/x64/lower.isle line 1948.
11983         let expr0_0: Type = I32;
11984         let expr1_0: u8 = 1;
11985         let expr2_0 = Imm8Reg::Imm8 { imm: expr1_0 };
11986         let expr3_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr2_0);
11987         let expr4_0 = constructor_x64_shr(ctx, expr0_0, pattern2_0, &expr3_0)?;
11988         let expr5_0: Type = I32;
11989         let expr6_0: u64 = 2004318071;
11990         let expr7_0 = constructor_imm(ctx, expr5_0, expr6_0)?;
11991         let expr8_0 = C::gpr_new(ctx, expr7_0);
11992         let expr9_0: Type = I32;
11993         let expr10_0 = C::gpr_to_gpr_mem_imm(ctx, expr8_0);
11994         let expr11_0 = constructor_x64_and(ctx, expr9_0, expr4_0, &expr10_0)?;
11995         let expr12_0: Type = I32;
11996         let expr13_0 = C::gpr_to_gpr_mem_imm(ctx, expr11_0);
11997         let expr14_0 = constructor_x64_sub(ctx, expr12_0, pattern2_0, &expr13_0)?;
11998         let expr15_0: Type = I32;
11999         let expr16_0: u8 = 1;
12000         let expr17_0 = Imm8Reg::Imm8 { imm: expr16_0 };
12001         let expr18_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr17_0);
12002         let expr19_0 = constructor_x64_shr(ctx, expr15_0, expr11_0, &expr18_0)?;
12003         let expr20_0: Type = I32;
12004         let expr21_0 = C::gpr_to_gpr_mem_imm(ctx, expr8_0);
12005         let expr22_0 = constructor_x64_and(ctx, expr20_0, expr19_0, &expr21_0)?;
12006         let expr23_0: Type = I32;
12007         let expr24_0 = C::gpr_to_gpr_mem_imm(ctx, expr22_0);
12008         let expr25_0 = constructor_x64_sub(ctx, expr23_0, expr14_0, &expr24_0)?;
12009         let expr26_0: Type = I32;
12010         let expr27_0: u8 = 1;
12011         let expr28_0 = Imm8Reg::Imm8 { imm: expr27_0 };
12012         let expr29_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr28_0);
12013         let expr30_0 = constructor_x64_shr(ctx, expr26_0, expr22_0, &expr29_0)?;
12014         let expr31_0: Type = I32;
12015         let expr32_0 = C::gpr_to_gpr_mem_imm(ctx, expr8_0);
12016         let expr33_0 = constructor_x64_and(ctx, expr31_0, expr30_0, &expr32_0)?;
12017         let expr34_0: Type = I32;
12018         let expr35_0 = C::gpr_to_gpr_mem_imm(ctx, expr33_0);
12019         let expr36_0 = constructor_x64_sub(ctx, expr34_0, expr25_0, &expr35_0)?;
12020         let expr37_0: Type = I32;
12021         let expr38_0: Type = I32;
12022         let expr39_0: u8 = 4;
12023         let expr40_0 = Imm8Reg::Imm8 { imm: expr39_0 };
12024         let expr41_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr40_0);
12025         let expr42_0 = constructor_x64_shr(ctx, expr38_0, expr36_0, &expr41_0)?;
12026         let expr43_0 = C::gpr_to_gpr_mem_imm(ctx, expr36_0);
12027         let expr44_0 = constructor_x64_add(ctx, expr37_0, expr42_0, &expr43_0)?;
12028         let expr45_0: Type = I32;
12029         let expr46_0: u32 = 252645135;
12030         let expr47_0 = RegMemImm::Imm { simm32: expr46_0 };
12031         let expr48_0 = C::gpr_mem_imm_new(ctx, &expr47_0);
12032         let expr49_0 = constructor_x64_and(ctx, expr45_0, expr44_0, &expr48_0)?;
12033         let expr50_0: Type = I32;
12034         let expr51_0: u32 = 16843009;
12035         let expr52_0 = RegMemImm::Imm { simm32: expr51_0 };
12036         let expr53_0 = C::gpr_mem_imm_new(ctx, &expr52_0);
12037         let expr54_0 = constructor_x64_mul(ctx, expr50_0, expr49_0, &expr53_0)?;
12038         let expr55_0: Type = I32;
12039         let expr56_0: u8 = 24;
12040         let expr57_0 = Imm8Reg::Imm8 { imm: expr56_0 };
12041         let expr58_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr57_0);
12042         let expr59_0 = constructor_x64_shr(ctx, expr55_0, expr54_0, &expr58_0)?;
12043         return Some(expr59_0);
12044     }
12045     if pattern0_0 == I64 {
12046         let pattern2_0 = arg1;
12047         // Rule at src/isa/x64/lower.isle line 1905.
12048         let expr0_0: Type = I64;
12049         let expr1_0: u8 = 1;
12050         let expr2_0 = Imm8Reg::Imm8 { imm: expr1_0 };
12051         let expr3_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr2_0);
12052         let expr4_0 = constructor_x64_shr(ctx, expr0_0, pattern2_0, &expr3_0)?;
12053         let expr5_0: Type = I64;
12054         let expr6_0: u64 = 8608480567731124087;
12055         let expr7_0 = constructor_imm(ctx, expr5_0, expr6_0)?;
12056         let expr8_0 = C::gpr_new(ctx, expr7_0);
12057         let expr9_0: Type = I64;
12058         let expr10_0 = C::gpr_to_gpr_mem_imm(ctx, expr8_0);
12059         let expr11_0 = constructor_x64_and(ctx, expr9_0, expr4_0, &expr10_0)?;
12060         let expr12_0: Type = I64;
12061         let expr13_0 = C::gpr_to_gpr_mem_imm(ctx, expr11_0);
12062         let expr14_0 = constructor_x64_sub(ctx, expr12_0, pattern2_0, &expr13_0)?;
12063         let expr15_0: Type = I64;
12064         let expr16_0: u8 = 1;
12065         let expr17_0 = Imm8Reg::Imm8 { imm: expr16_0 };
12066         let expr18_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr17_0);
12067         let expr19_0 = constructor_x64_shr(ctx, expr15_0, expr11_0, &expr18_0)?;
12068         let expr20_0: Type = I64;
12069         let expr21_0 = C::gpr_to_gpr_mem_imm(ctx, expr8_0);
12070         let expr22_0 = constructor_x64_and(ctx, expr20_0, expr19_0, &expr21_0)?;
12071         let expr23_0: Type = I64;
12072         let expr24_0 = C::gpr_to_gpr_mem_imm(ctx, expr22_0);
12073         let expr25_0 = constructor_x64_sub(ctx, expr23_0, expr14_0, &expr24_0)?;
12074         let expr26_0: Type = I64;
12075         let expr27_0: u8 = 1;
12076         let expr28_0 = Imm8Reg::Imm8 { imm: expr27_0 };
12077         let expr29_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr28_0);
12078         let expr30_0 = constructor_x64_shr(ctx, expr26_0, expr22_0, &expr29_0)?;
12079         let expr31_0: Type = I64;
12080         let expr32_0 = C::gpr_to_gpr_mem_imm(ctx, expr8_0);
12081         let expr33_0 = constructor_x64_and(ctx, expr31_0, expr30_0, &expr32_0)?;
12082         let expr34_0: Type = I64;
12083         let expr35_0 = C::gpr_to_gpr_mem_imm(ctx, expr33_0);
12084         let expr36_0 = constructor_x64_sub(ctx, expr34_0, expr25_0, &expr35_0)?;
12085         let expr37_0: Type = I64;
12086         let expr38_0: Type = I64;
12087         let expr39_0: u8 = 4;
12088         let expr40_0 = Imm8Reg::Imm8 { imm: expr39_0 };
12089         let expr41_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr40_0);
12090         let expr42_0 = constructor_x64_shr(ctx, expr38_0, expr36_0, &expr41_0)?;
12091         let expr43_0 = C::gpr_to_gpr_mem_imm(ctx, expr36_0);
12092         let expr44_0 = constructor_x64_add(ctx, expr37_0, expr42_0, &expr43_0)?;
12093         let expr45_0: Type = I64;
12094         let expr46_0: u64 = 1085102592571150095;
12095         let expr47_0 = constructor_imm(ctx, expr45_0, expr46_0)?;
12096         let expr48_0 = C::gpr_new(ctx, expr47_0);
12097         let expr49_0: Type = I64;
12098         let expr50_0 = C::gpr_to_gpr_mem_imm(ctx, expr48_0);
12099         let expr51_0 = constructor_x64_and(ctx, expr49_0, expr44_0, &expr50_0)?;
12100         let expr52_0: Type = I64;
12101         let expr53_0: u64 = 72340172838076673;
12102         let expr54_0 = constructor_imm(ctx, expr52_0, expr53_0)?;
12103         let expr55_0 = C::gpr_new(ctx, expr54_0);
12104         let expr56_0: Type = I64;
12105         let expr57_0 = C::gpr_to_gpr_mem_imm(ctx, expr55_0);
12106         let expr58_0 = constructor_x64_mul(ctx, expr56_0, expr51_0, &expr57_0)?;
12107         let expr59_0: Type = I64;
12108         let expr60_0: u8 = 56;
12109         let expr61_0 = Imm8Reg::Imm8 { imm: expr60_0 };
12110         let expr62_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr61_0);
12111         let expr63_0 = constructor_x64_shr(ctx, expr59_0, expr58_0, &expr62_0)?;
12112         return Some(expr63_0);
12113     }
12114     return None;
12115 }
12116 
12117 // Generated as internal constructor for term do_bitrev8.
12118 pub fn constructor_do_bitrev8<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Option<Gpr> {
12119     let pattern0_0 = arg0;
12120     let pattern1_0 = arg1;
12121     // Rule at src/isa/x64/lower.isle line 2037.
12122     let expr0_0 = C::ty_mask(ctx, pattern0_0);
12123     let expr1_0: u64 = 6148914691236517205;
12124     let expr2_0 = C::u64_and(ctx, expr0_0, expr1_0)?;
12125     let expr3_0 = constructor_imm(ctx, pattern0_0, expr2_0)?;
12126     let expr4_0 = C::gpr_new(ctx, expr3_0);
12127     let expr5_0 = C::gpr_to_gpr_mem_imm(ctx, expr4_0);
12128     let expr6_0 = constructor_x64_and(ctx, pattern0_0, pattern1_0, &expr5_0)?;
12129     let expr7_0: u8 = 1;
12130     let expr8_0 = Imm8Reg::Imm8 { imm: expr7_0 };
12131     let expr9_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr8_0);
12132     let expr10_0 = constructor_x64_shr(ctx, pattern0_0, pattern1_0, &expr9_0)?;
12133     let expr11_0 = C::gpr_to_gpr_mem_imm(ctx, expr4_0);
12134     let expr12_0 = constructor_x64_and(ctx, pattern0_0, expr10_0, &expr11_0)?;
12135     let expr13_0: u8 = 1;
12136     let expr14_0 = Imm8Reg::Imm8 { imm: expr13_0 };
12137     let expr15_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr14_0);
12138     let expr16_0 = constructor_x64_shl(ctx, pattern0_0, expr6_0, &expr15_0)?;
12139     let expr17_0 = C::gpr_to_gpr_mem_imm(ctx, expr12_0);
12140     let expr18_0 = constructor_x64_or(ctx, pattern0_0, expr16_0, &expr17_0)?;
12141     let expr19_0: u64 = 3689348814741910323;
12142     let expr20_0 = C::u64_and(ctx, expr0_0, expr19_0)?;
12143     let expr21_0 = constructor_imm(ctx, pattern0_0, expr20_0)?;
12144     let expr22_0 = C::gpr_new(ctx, expr21_0);
12145     let expr23_0 = C::gpr_to_gpr_mem_imm(ctx, expr22_0);
12146     let expr24_0 = constructor_x64_and(ctx, pattern0_0, expr18_0, &expr23_0)?;
12147     let expr25_0: u8 = 2;
12148     let expr26_0 = Imm8Reg::Imm8 { imm: expr25_0 };
12149     let expr27_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr26_0);
12150     let expr28_0 = constructor_x64_shr(ctx, pattern0_0, expr18_0, &expr27_0)?;
12151     let expr29_0 = C::gpr_to_gpr_mem_imm(ctx, expr22_0);
12152     let expr30_0 = constructor_x64_and(ctx, pattern0_0, expr28_0, &expr29_0)?;
12153     let expr31_0: u8 = 2;
12154     let expr32_0 = Imm8Reg::Imm8 { imm: expr31_0 };
12155     let expr33_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr32_0);
12156     let expr34_0 = constructor_x64_shl(ctx, pattern0_0, expr24_0, &expr33_0)?;
12157     let expr35_0 = C::gpr_to_gpr_mem_imm(ctx, expr30_0);
12158     let expr36_0 = constructor_x64_or(ctx, pattern0_0, expr34_0, &expr35_0)?;
12159     let expr37_0: u64 = 1085102592571150095;
12160     let expr38_0 = C::u64_and(ctx, expr0_0, expr37_0)?;
12161     let expr39_0 = constructor_imm(ctx, pattern0_0, expr38_0)?;
12162     let expr40_0 = C::gpr_new(ctx, expr39_0);
12163     let expr41_0 = C::gpr_to_gpr_mem_imm(ctx, expr40_0);
12164     let expr42_0 = constructor_x64_and(ctx, pattern0_0, expr36_0, &expr41_0)?;
12165     let expr43_0: u8 = 4;
12166     let expr44_0 = Imm8Reg::Imm8 { imm: expr43_0 };
12167     let expr45_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr44_0);
12168     let expr46_0 = constructor_x64_shr(ctx, pattern0_0, expr36_0, &expr45_0)?;
12169     let expr47_0 = C::gpr_to_gpr_mem_imm(ctx, expr40_0);
12170     let expr48_0 = constructor_x64_and(ctx, pattern0_0, expr46_0, &expr47_0)?;
12171     let expr49_0: u8 = 4;
12172     let expr50_0 = Imm8Reg::Imm8 { imm: expr49_0 };
12173     let expr51_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr50_0);
12174     let expr52_0 = constructor_x64_shl(ctx, pattern0_0, expr42_0, &expr51_0)?;
12175     let expr53_0 = C::gpr_to_gpr_mem_imm(ctx, expr48_0);
12176     let expr54_0 = constructor_x64_or(ctx, pattern0_0, expr52_0, &expr53_0)?;
12177     return Some(expr54_0);
12178 }
12179 
12180 // Generated as internal constructor for term do_bitrev16.
12181 pub fn constructor_do_bitrev16<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Option<Gpr> {
12182     let pattern0_0 = arg0;
12183     let pattern1_0 = arg1;
12184     // Rule at src/isa/x64/lower.isle line 2060.
12185     let expr0_0 = constructor_do_bitrev8(ctx, pattern0_0, pattern1_0)?;
12186     let expr1_0 = C::ty_mask(ctx, pattern0_0);
12187     let expr2_0: u64 = 71777214294589695;
12188     let expr3_0 = C::u64_and(ctx, expr1_0, expr2_0)?;
12189     let expr4_0 = constructor_imm(ctx, pattern0_0, expr3_0)?;
12190     let expr5_0 = C::gpr_new(ctx, expr4_0);
12191     let expr6_0 = C::gpr_to_gpr_mem_imm(ctx, expr5_0);
12192     let expr7_0 = constructor_x64_and(ctx, pattern0_0, expr0_0, &expr6_0)?;
12193     let expr8_0: u8 = 8;
12194     let expr9_0 = Imm8Reg::Imm8 { imm: expr8_0 };
12195     let expr10_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr9_0);
12196     let expr11_0 = constructor_x64_shr(ctx, pattern0_0, expr0_0, &expr10_0)?;
12197     let expr12_0 = C::gpr_to_gpr_mem_imm(ctx, expr5_0);
12198     let expr13_0 = constructor_x64_and(ctx, pattern0_0, expr11_0, &expr12_0)?;
12199     let expr14_0: u8 = 8;
12200     let expr15_0 = Imm8Reg::Imm8 { imm: expr14_0 };
12201     let expr16_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr15_0);
12202     let expr17_0 = constructor_x64_shl(ctx, pattern0_0, expr7_0, &expr16_0)?;
12203     let expr18_0 = C::gpr_to_gpr_mem_imm(ctx, expr13_0);
12204     let expr19_0 = constructor_x64_or(ctx, pattern0_0, expr17_0, &expr18_0)?;
12205     return Some(expr19_0);
12206 }
12207 
12208 // Generated as internal constructor for term do_bitrev32.
12209 pub fn constructor_do_bitrev32<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Option<Gpr> {
12210     let pattern0_0 = arg0;
12211     let pattern1_0 = arg1;
12212     // Rule at src/isa/x64/lower.isle line 2072.
12213     let expr0_0 = constructor_do_bitrev16(ctx, pattern0_0, pattern1_0)?;
12214     let expr1_0 = C::ty_mask(ctx, pattern0_0);
12215     let expr2_0: u64 = 281470681808895;
12216     let expr3_0 = C::u64_and(ctx, expr1_0, expr2_0)?;
12217     let expr4_0 = constructor_imm(ctx, pattern0_0, expr3_0)?;
12218     let expr5_0 = C::gpr_new(ctx, expr4_0);
12219     let expr6_0 = C::gpr_to_gpr_mem_imm(ctx, expr5_0);
12220     let expr7_0 = constructor_x64_and(ctx, pattern0_0, expr0_0, &expr6_0)?;
12221     let expr8_0: u8 = 16;
12222     let expr9_0 = Imm8Reg::Imm8 { imm: expr8_0 };
12223     let expr10_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr9_0);
12224     let expr11_0 = constructor_x64_shr(ctx, pattern0_0, expr0_0, &expr10_0)?;
12225     let expr12_0 = C::gpr_to_gpr_mem_imm(ctx, expr5_0);
12226     let expr13_0 = constructor_x64_and(ctx, pattern0_0, expr11_0, &expr12_0)?;
12227     let expr14_0: u8 = 16;
12228     let expr15_0 = Imm8Reg::Imm8 { imm: expr14_0 };
12229     let expr16_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr15_0);
12230     let expr17_0 = constructor_x64_shl(ctx, pattern0_0, expr7_0, &expr16_0)?;
12231     let expr18_0 = C::gpr_to_gpr_mem_imm(ctx, expr13_0);
12232     let expr19_0 = constructor_x64_or(ctx, pattern0_0, expr17_0, &expr18_0)?;
12233     return Some(expr19_0);
12234 }
12235 
12236 // Generated as internal constructor for term do_bitrev64.
12237 pub fn constructor_do_bitrev64<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Option<Gpr> {
12238     let pattern0_0 = arg0;
12239     if pattern0_0 == I64 {
12240         let pattern2_0 = arg1;
12241         // Rule at src/isa/x64/lower.isle line 2084.
12242         let expr0_0 = constructor_do_bitrev32(ctx, pattern0_0, pattern2_0)?;
12243         let expr1_0: u64 = 4294967295;
12244         let expr2_0 = constructor_imm(ctx, pattern0_0, expr1_0)?;
12245         let expr3_0 = C::gpr_new(ctx, expr2_0);
12246         let expr4_0 = C::gpr_to_gpr_mem_imm(ctx, expr3_0);
12247         let expr5_0 = constructor_x64_and(ctx, pattern0_0, expr0_0, &expr4_0)?;
12248         let expr6_0: u8 = 32;
12249         let expr7_0 = Imm8Reg::Imm8 { imm: expr6_0 };
12250         let expr8_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr7_0);
12251         let expr9_0 = constructor_x64_shr(ctx, pattern0_0, expr0_0, &expr8_0)?;
12252         let expr10_0: u8 = 32;
12253         let expr11_0 = Imm8Reg::Imm8 { imm: expr10_0 };
12254         let expr12_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr11_0);
12255         let expr13_0 = constructor_x64_shl(ctx, pattern0_0, expr5_0, &expr12_0)?;
12256         let expr14_0 = C::gpr_to_gpr_mem_imm(ctx, expr9_0);
12257         let expr15_0 = constructor_x64_or(ctx, pattern0_0, expr13_0, &expr14_0)?;
12258         return Some(expr15_0);
12259     }
12260     return None;
12261 }
12262 
12263 // Generated as internal constructor for term generic_sextend.
12264 pub fn constructor_generic_sextend<C: Context>(
12265     ctx: &mut C,
12266     arg0: Value,
12267     arg1: Type,
12268     arg2: Type,
12269 ) -> Option<InstOutput> {
12270     let pattern0_0 = arg0;
12271     let pattern1_0 = arg1;
12272     if let Some(pattern2_0) = C::fits_in_32(ctx, pattern1_0) {
12273         let pattern3_0 = arg2;
12274         if let Some(pattern4_0) = C::fits_in_32(ctx, pattern3_0) {
12275             // Rule at src/isa/x64/lower.isle line 2204.
12276             let expr0_0: Type = I32;
12277             let expr1_0 = ExtendKind::Sign;
12278             let expr2_0 = constructor_extend_to_gpr(ctx, pattern0_0, expr0_0, &expr1_0)?;
12279             let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
12280             return Some(expr3_0);
12281         }
12282         if let Some(pattern4_0) = C::ty_int_bool_64(ctx, pattern3_0) {
12283             // Rule at src/isa/x64/lower.isle line 2200.
12284             let expr0_0: Type = I64;
12285             let expr1_0 = ExtendKind::Sign;
12286             let expr2_0 = constructor_extend_to_gpr(ctx, pattern0_0, expr0_0, &expr1_0)?;
12287             let expr3_0 = constructor_output_gpr(ctx, expr2_0)?;
12288             return Some(expr3_0);
12289         }
12290         if let Some(pattern4_0) = C::ty_int_bool_128(ctx, pattern3_0) {
12291             // Rule at src/isa/x64/lower.isle line 2194.
12292             let expr0_0: Type = I64;
12293             let expr1_0 = ExtendKind::Sign;
12294             let expr2_0 = constructor_extend_to_gpr(ctx, pattern0_0, expr0_0, &expr1_0)?;
12295             let expr3_0 = constructor_spread_sign_bit(ctx, expr2_0)?;
12296             let expr4_0 = C::gpr_to_reg(ctx, expr2_0);
12297             let expr5_0 = C::gpr_to_reg(ctx, expr3_0);
12298             let expr6_0 = C::value_regs(ctx, expr4_0, expr5_0);
12299             let expr7_0 = C::output(ctx, expr6_0);
12300             return Some(expr7_0);
12301         }
12302     }
12303     if let Some(pattern2_0) = C::ty_int_bool_64(ctx, pattern1_0) {
12304         let pattern3_0 = arg2;
12305         if let Some(pattern4_0) = C::ty_int_bool_128(ctx, pattern3_0) {
12306             // Rule at src/isa/x64/lower.isle line 2190.
12307             let expr0_0 = C::put_in_reg(ctx, pattern0_0);
12308             let expr1_0 = constructor_put_in_gpr(ctx, pattern0_0)?;
12309             let expr2_0 = constructor_spread_sign_bit(ctx, expr1_0)?;
12310             let expr3_0 = C::gpr_to_reg(ctx, expr2_0);
12311             let expr4_0 = C::value_regs(ctx, expr0_0, expr3_0);
12312             let expr5_0 = C::output(ctx, expr4_0);
12313             return Some(expr5_0);
12314         }
12315     }
12316     let pattern2_0 = arg2;
12317     if pattern2_0 == pattern1_0 {
12318         // Rule at src/isa/x64/lower.isle line 2180.
12319         let expr0_0 = constructor_output_value(ctx, pattern0_0)?;
12320         return Some(expr0_0);
12321     }
12322     return None;
12323 }
12324 
12325 // Generated as internal constructor for term spread_sign_bit.
12326 pub fn constructor_spread_sign_bit<C: Context>(ctx: &mut C, arg0: Gpr) -> Option<Gpr> {
12327     let pattern0_0 = arg0;
12328     // Rule at src/isa/x64/lower.isle line 2186.
12329     let expr0_0: Type = I64;
12330     let expr1_0: u8 = 63;
12331     let expr2_0 = Imm8Reg::Imm8 { imm: expr1_0 };
12332     let expr3_0 = C::imm8_reg_to_imm8_gpr(ctx, &expr2_0);
12333     let expr4_0 = constructor_x64_sar(ctx, expr0_0, pattern0_0, &expr3_0)?;
12334     return Some(expr4_0);
12335 }
12336