;; GENERATED BY `gen_isle`. DO NOT EDIT!!!
;;
;; This ISLE file defines all the external type declarations for Cranelift's
;; data structures that ISLE will process, such as `InstructionData` and
;; `Opcode`.

;;;; Extern type declarations for immediates ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(type Constant (primitive Constant))
(type DynamicStackSlot (primitive DynamicStackSlot))
(type FuncRef (primitive FuncRef))
(type GlobalValue (primitive GlobalValue))
(type Ieee16 (primitive Ieee16))
(type Ieee32 (primitive Ieee32))
(type Ieee64 (primitive Ieee64))
(type Imm64 (primitive Imm64))
(type Immediate (primitive Immediate))
(type JumpTable (primitive JumpTable))
(type MemFlags (primitive MemFlags))
(type Offset32 (primitive Offset32))
(type SigRef (primitive SigRef))
(type StackSlot (primitive StackSlot))
(type Uimm8 (primitive Uimm8))

;;;; Enumerated Immediate: AtomicRmwOp ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(type AtomicRmwOp extern
    (enum
        Add
        And
        Nand
        Or
        Smax
        Smin
        Sub
        Umax
        Umin
        Xchg
        Xor
    )
)

;;;; Enumerated Immediate: FloatCC ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(type FloatCC extern
    (enum
        Equal
        GreaterThan
        GreaterThanOrEqual
        LessThan
        LessThanOrEqual
        NotEqual
        Ordered
        OrderedNotEqual
        Unordered
        UnorderedOrEqual
        UnorderedOrGreaterThan
        UnorderedOrGreaterThanOrEqual
        UnorderedOrLessThan
        UnorderedOrLessThanOrEqual
    )
)

;;;; Enumerated Immediate: IntCC ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(type IntCC extern
    (enum
        Equal
        NotEqual
        SignedGreaterThan
        SignedGreaterThanOrEqual
        SignedLessThan
        SignedLessThanOrEqual
        UnsignedGreaterThan
        UnsignedGreaterThanOrEqual
        UnsignedLessThan
        UnsignedLessThanOrEqual
    )
)

;;;; Enumerated Immediate: TrapCode ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(type TrapCode extern
    (enum
        BAD_CONVERSION_TO_INTEGER
        HEAP_OUT_OF_BOUNDS
        INTEGER_DIVISION_BY_ZERO
        INTEGER_OVERFLOW
        STACK_OVERFLOW
    )
)

;;;; Value Arrays ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;; ISLE representation of `[Value; 2]`.
(type ValueArray2 extern (enum))

(decl value_array_2 (Value Value) ValueArray2)
(extern constructor value_array_2 pack_value_array_2)
(extern extractor infallible value_array_2 unpack_value_array_2)

;; ISLE representation of `[Value; 3]`.
(type ValueArray3 extern (enum))

(decl value_array_3 (Value Value Value) ValueArray3)
(extern constructor value_array_3 pack_value_array_3)
(extern extractor infallible value_array_3 unpack_value_array_3)

;;;; Block Arrays ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;; ISLE representation of `[BlockCall; 2]`.
(type BlockArray2 extern (enum))

(decl block_array_2 (BlockCall BlockCall) BlockArray2)
(extern constructor block_array_2 pack_block_array_2)
(extern extractor infallible block_array_2 unpack_block_array_2)

;;;; `Opcode` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(type Opcode extern
    (enum
        Jump
        Brif
        BrTable
        Debugtrap
        Trap
        Trapz
        Trapnz
        Return
        Call
        CallIndirect
        ReturnCall
        ReturnCallIndirect
        FuncAddr
        Splat
        Swizzle
        X86Pshufb
        Insertlane
        Extractlane
        Smin
        Umin
        Smax
        Umax
        AvgRound
        UaddSat
        SaddSat
        UsubSat
        SsubSat
        Load
        Store
        Uload8
        Sload8
        Istore8
        Uload16
        Sload16
        Istore16
        Uload32
        Sload32
        Istore32
        StackSwitch
        Uload8x8
        Sload8x8
        Uload16x4
        Sload16x4
        Uload32x2
        Sload32x2
        StackLoad
        StackStore
        StackAddr
        DynamicStackLoad
        DynamicStackStore
        DynamicStackAddr
        GlobalValue
        SymbolValue
        TlsValue
        GetPinnedReg
        SetPinnedReg
        GetFramePointer
        GetStackPointer
        GetReturnAddress
        Iconst
        F16const
        F32const
        F64const
        F128const
        Vconst
        Shuffle
        Nop
        Select
        SelectSpectreGuard
        Bitselect
        X86Blendv
        VanyTrue
        VallTrue
        VhighBits
        Icmp
        IcmpImm
        Iadd
        Isub
        Ineg
        Iabs
        Imul
        Umulhi
        Smulhi
        SqmulRoundSat
        X86Pmulhrsw
        Udiv
        Sdiv
        Urem
        Srem
        IaddImm
        ImulImm
        UdivImm
        SdivImm
        UremImm
        SremImm
        IrsubImm
        SaddOverflowCin
        UaddOverflowCin
        UaddOverflow
        SaddOverflow
        UsubOverflow
        SsubOverflow
        UmulOverflow
        SmulOverflow
        UaddOverflowTrap
        SsubOverflowBin
        UsubOverflowBin
        Band
        Bor
        Bxor
        Bnot
        BandNot
        BorNot
        BxorNot
        BandImm
        BorImm
        BxorImm
        Rotl
        Rotr
        RotlImm
        RotrImm
        Ishl
        Ushr
        Sshr
        IshlImm
        UshrImm
        SshrImm
        Bitrev
        Clz
        Cls
        Ctz
        Bswap
        Popcnt
        Fcmp
        Fadd
        Fsub
        Fmul
        Fdiv
        Sqrt
        Fma
        Fneg
        Fabs
        Fcopysign
        Fmin
        Fmax
        Ceil
        Floor
        Trunc
        Nearest
        Bitcast
        ScalarToVector
        Bmask
        Ireduce
        Snarrow
        Unarrow
        Uunarrow
        SwidenLow
        SwidenHigh
        UwidenLow
        UwidenHigh
        IaddPairwise
        X86Pmaddubsw
        Uextend
        Sextend
        Fpromote
        Fdemote
        Fvdemote
        FvpromoteLow
        FcvtToUint
        FcvtToSint
        FcvtToUintSat
        FcvtToSintSat
        X86Cvtt2dq
        FcvtFromUint
        FcvtFromSint
        Isplit
        Iconcat
        AtomicRmw
        AtomicCas
        AtomicLoad
        AtomicStore
        Fence
        ExtractVector
    )
)

;;;; `InstructionData` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(type InstructionData extern
    (enum
        (AtomicCas (opcode Opcode) (args ValueArray3) (flags MemFlags))
        (AtomicRmw (opcode Opcode) (args ValueArray2) (flags MemFlags) (op AtomicRmwOp))
        (Binary (opcode Opcode) (args ValueArray2))
        (BinaryImm64 (opcode Opcode) (arg Value) (imm Imm64))
        (BinaryImm8 (opcode Opcode) (arg Value) (imm Uimm8))
        (BranchTable (opcode Opcode) (arg Value) (table JumpTable))
        (Brif (opcode Opcode) (arg Value) (blocks BlockArray2))
        (Call (opcode Opcode) (args ValueList) (func_ref FuncRef))
        (CallIndirect (opcode Opcode) (args ValueList) (sig_ref SigRef))
        (CondTrap (opcode Opcode) (arg Value) (code TrapCode))
        (DynamicStackLoad (opcode Opcode) (dynamic_stack_slot DynamicStackSlot))
        (DynamicStackStore (opcode Opcode) (arg Value) (dynamic_stack_slot DynamicStackSlot))
        (FloatCompare (opcode Opcode) (args ValueArray2) (cond FloatCC))
        (FuncAddr (opcode Opcode) (func_ref FuncRef))
        (IntAddTrap (opcode Opcode) (args ValueArray2) (code TrapCode))
        (IntCompare (opcode Opcode) (args ValueArray2) (cond IntCC))
        (IntCompareImm (opcode Opcode) (arg Value) (cond IntCC) (imm Imm64))
        (Jump (opcode Opcode) (destination BlockCall))
        (Load (opcode Opcode) (arg Value) (flags MemFlags) (offset Offset32))
        (LoadNoOffset (opcode Opcode) (arg Value) (flags MemFlags))
        (MultiAry (opcode Opcode) (args ValueList))
        (NullAry (opcode Opcode))
        (Shuffle (opcode Opcode) (args ValueArray2) (imm Immediate))
        (StackLoad (opcode Opcode) (stack_slot StackSlot) (offset Offset32))
        (StackStore (opcode Opcode) (arg Value) (stack_slot StackSlot) (offset Offset32))
        (Store (opcode Opcode) (args ValueArray2) (flags MemFlags) (offset Offset32))
        (StoreNoOffset (opcode Opcode) (args ValueArray2) (flags MemFlags))
        (Ternary (opcode Opcode) (args ValueArray3))
        (TernaryImm8 (opcode Opcode) (args ValueArray2) (imm Uimm8))
        (Trap (opcode Opcode) (code TrapCode))
        (Unary (opcode Opcode) (arg Value))
        (UnaryConst (opcode Opcode) (constant_handle Constant))
        (UnaryGlobalValue (opcode Opcode) (global_value GlobalValue))
        (UnaryIeee16 (opcode Opcode) (imm Ieee16))
        (UnaryIeee32 (opcode Opcode) (imm Ieee32))
        (UnaryIeee64 (opcode Opcode) (imm Ieee64))
        (UnaryImm (opcode Opcode) (imm Imm64))
    )
)

;;;; Extracting Opcode, Operands, and Immediates from `InstructionData` ;;;;;;;;

(decl func_addr (Type FuncRef) Value)
(extractor
    (func_addr ty FN)
    (inst_data ty (InstructionData.FuncAddr (Opcode.FuncAddr) FN))
)
(rule (func_addr ty FN)
    (make_inst ty (InstructionData.FuncAddr (Opcode.FuncAddr) FN))
)

(decl splat (Type Value) Value)
(extractor
    (splat ty x)
    (inst_data ty (InstructionData.Unary (Opcode.Splat) x))
)
(rule (splat ty x)
    (make_inst ty (InstructionData.Unary (Opcode.Splat) x))
)

(decl swizzle (Type Value Value) Value)
(extractor
    (swizzle ty x y)
    (inst_data ty (InstructionData.Binary (Opcode.Swizzle) (value_array_2 x y)))
)
(rule (swizzle ty x y)
    (make_inst ty (InstructionData.Binary (Opcode.Swizzle) (value_array_2_ctor x y)))
)

(decl x86_pshufb (Type Value Value) Value)
(extractor
    (x86_pshufb ty x y)
    (inst_data ty (InstructionData.Binary (Opcode.X86Pshufb) (value_array_2 x y)))
)
(rule (x86_pshufb ty x y)
    (make_inst ty (InstructionData.Binary (Opcode.X86Pshufb) (value_array_2_ctor x y)))
)

(decl insertlane (Type Value Value Uimm8) Value)
(extractor
    (insertlane ty x y Idx)
    (inst_data ty (InstructionData.TernaryImm8 (Opcode.Insertlane) (value_array_2 x y) Idx))
)
(rule (insertlane ty x y Idx)
    (make_inst ty (InstructionData.TernaryImm8 (Opcode.Insertlane) (value_array_2_ctor x y) Idx))
)

(decl extractlane (Type Value Uimm8) Value)
(extractor
    (extractlane ty x Idx)
    (inst_data ty (InstructionData.BinaryImm8 (Opcode.Extractlane) x Idx))
)
(rule (extractlane ty x Idx)
    (make_inst ty (InstructionData.BinaryImm8 (Opcode.Extractlane) x Idx))
)

(decl smin (Type Value Value) Value)
(extractor
    (smin ty x y)
    (inst_data ty (InstructionData.Binary (Opcode.Smin) (value_array_2 x y)))
)
(rule (smin ty x y)
    (make_inst ty (InstructionData.Binary (Opcode.Smin) (value_array_2_ctor x y)))
)

(decl umin (Type Value Value) Value)
(extractor
    (umin ty x y)
    (inst_data ty (InstructionData.Binary (Opcode.Umin) (value_array_2 x y)))
)
(rule (umin ty x y)
    (make_inst ty (InstructionData.Binary (Opcode.Umin) (value_array_2_ctor x y)))
)

(decl smax (Type Value Value) Value)
(extractor
    (smax ty x y)
    (inst_data ty (InstructionData.Binary (Opcode.Smax) (value_array_2 x y)))
)
(rule (smax ty x y)
    (make_inst ty (InstructionData.Binary (Opcode.Smax) (value_array_2_ctor x y)))
)

(decl umax (Type Value Value) Value)
(extractor
    (umax ty x y)
    (inst_data ty (InstructionData.Binary (Opcode.Umax) (value_array_2 x y)))
)
(rule (umax ty x y)
    (make_inst ty (InstructionData.Binary (Opcode.Umax) (value_array_2_ctor x y)))
)

(decl avg_round (Type Value Value) Value)
(extractor
    (avg_round ty x y)
    (inst_data ty (InstructionData.Binary (Opcode.AvgRound) (value_array_2 x y)))
)
(rule (avg_round ty x y)
    (make_inst ty (InstructionData.Binary (Opcode.AvgRound) (value_array_2_ctor x y)))
)

(decl uadd_sat (Type Value Value) Value)
(extractor
    (uadd_sat ty x y)
    (inst_data ty (InstructionData.Binary (Opcode.UaddSat) (value_array_2 x y)))
)
(rule (uadd_sat ty x y)
    (make_inst ty (InstructionData.Binary (Opcode.UaddSat) (value_array_2_ctor x y)))
)

(decl sadd_sat (Type Value Value) Value)
(extractor
    (sadd_sat ty x y)
    (inst_data ty (InstructionData.Binary (Opcode.SaddSat) (value_array_2 x y)))
)
(rule (sadd_sat ty x y)
    (make_inst ty (InstructionData.Binary (Opcode.SaddSat) (value_array_2_ctor x y)))
)

(decl usub_sat (Type Value Value) Value)
(extractor
    (usub_sat ty x y)
    (inst_data ty (InstructionData.Binary (Opcode.UsubSat) (value_array_2 x y)))
)
(rule (usub_sat ty x y)
    (make_inst ty (InstructionData.Binary (Opcode.UsubSat) (value_array_2_ctor x y)))
)

(decl ssub_sat (Type Value Value) Value)
(extractor
    (ssub_sat ty x y)
    (inst_data ty (InstructionData.Binary (Opcode.SsubSat) (value_array_2 x y)))
)
(rule (ssub_sat ty x y)
    (make_inst ty (InstructionData.Binary (Opcode.SsubSat) (value_array_2_ctor x y)))
)

(decl load (Type MemFlags Value Offset32) Value)
(extractor
    (load ty MemFlags p Offset)
    (inst_data ty (InstructionData.Load (Opcode.Load) p MemFlags Offset))
)
(rule (load ty MemFlags p Offset)
    (make_inst ty (InstructionData.Load (Opcode.Load) p MemFlags Offset))
)

(decl uload8 (Type MemFlags Value Offset32) Value)
(extractor
    (uload8 ty MemFlags p Offset)
    (inst_data ty (InstructionData.Load (Opcode.Uload8) p MemFlags Offset))
)
(rule (uload8 ty MemFlags p Offset)
    (make_inst ty (InstructionData.Load (Opcode.Uload8) p MemFlags Offset))
)

(decl sload8 (Type MemFlags Value Offset32) Value)
(extractor
    (sload8 ty MemFlags p Offset)
    (inst_data ty (InstructionData.Load (Opcode.Sload8) p MemFlags Offset))
)
(rule (sload8 ty MemFlags p Offset)
    (make_inst ty (InstructionData.Load (Opcode.Sload8) p MemFlags Offset))
)

(decl uload16 (Type MemFlags Value Offset32) Value)
(extractor
    (uload16 ty MemFlags p Offset)
    (inst_data ty (InstructionData.Load (Opcode.Uload16) p MemFlags Offset))
)
(rule (uload16 ty MemFlags p Offset)
    (make_inst ty (InstructionData.Load (Opcode.Uload16) p MemFlags Offset))
)

(decl sload16 (Type MemFlags Value Offset32) Value)
(extractor
    (sload16 ty MemFlags p Offset)
    (inst_data ty (InstructionData.Load (Opcode.Sload16) p MemFlags Offset))
)
(rule (sload16 ty MemFlags p Offset)
    (make_inst ty (InstructionData.Load (Opcode.Sload16) p MemFlags Offset))
)

(decl uload32 (Type MemFlags Value Offset32) Value)
(extractor
    (uload32 ty MemFlags p Offset)
    (inst_data ty (InstructionData.Load (Opcode.Uload32) p MemFlags Offset))
)
(rule (uload32 ty MemFlags p Offset)
    (make_inst ty (InstructionData.Load (Opcode.Uload32) p MemFlags Offset))
)

(decl sload32 (Type MemFlags Value Offset32) Value)
(extractor
    (sload32 ty MemFlags p Offset)
    (inst_data ty (InstructionData.Load (Opcode.Sload32) p MemFlags Offset))
)
(rule (sload32 ty MemFlags p Offset)
    (make_inst ty (InstructionData.Load (Opcode.Sload32) p MemFlags Offset))
)

(decl stack_switch (Type Value Value Value) Value)
(extractor
    (stack_switch ty store_context_ptr load_context_ptr in_payload0)
    (inst_data ty (InstructionData.Ternary (Opcode.StackSwitch) (value_array_3 store_context_ptr load_context_ptr in_payload0)))
)
(rule (stack_switch ty store_context_ptr load_context_ptr in_payload0)
    (make_inst ty (InstructionData.Ternary (Opcode.StackSwitch) (value_array_3_ctor store_context_ptr load_context_ptr in_payload0)))
)

(decl uload8x8 (Type MemFlags Value Offset32) Value)
(extractor
    (uload8x8 ty MemFlags p Offset)
    (inst_data ty (InstructionData.Load (Opcode.Uload8x8) p MemFlags Offset))
)
(rule (uload8x8 ty MemFlags p Offset)
    (make_inst ty (InstructionData.Load (Opcode.Uload8x8) p MemFlags Offset))
)

(decl sload8x8 (Type MemFlags Value Offset32) Value)
(extractor
    (sload8x8 ty MemFlags p Offset)
    (inst_data ty (InstructionData.Load (Opcode.Sload8x8) p MemFlags Offset))
)
(rule (sload8x8 ty MemFlags p Offset)
    (make_inst ty (InstructionData.Load (Opcode.Sload8x8) p MemFlags Offset))
)

(decl uload16x4 (Type MemFlags Value Offset32) Value)
(extractor
    (uload16x4 ty MemFlags p Offset)
    (inst_data ty (InstructionData.Load (Opcode.Uload16x4) p MemFlags Offset))
)
(rule (uload16x4 ty MemFlags p Offset)
    (make_inst ty (InstructionData.Load (Opcode.Uload16x4) p MemFlags Offset))
)

(decl sload16x4 (Type MemFlags Value Offset32) Value)
(extractor
    (sload16x4 ty MemFlags p Offset)
    (inst_data ty (InstructionData.Load (Opcode.Sload16x4) p MemFlags Offset))
)
(rule (sload16x4 ty MemFlags p Offset)
    (make_inst ty (InstructionData.Load (Opcode.Sload16x4) p MemFlags Offset))
)

(decl uload32x2 (Type MemFlags Value Offset32) Value)
(extractor
    (uload32x2 ty MemFlags p Offset)
    (inst_data ty (InstructionData.Load (Opcode.Uload32x2) p MemFlags Offset))
)
(rule (uload32x2 ty MemFlags p Offset)
    (make_inst ty (InstructionData.Load (Opcode.Uload32x2) p MemFlags Offset))
)

(decl sload32x2 (Type MemFlags Value Offset32) Value)
(extractor
    (sload32x2 ty MemFlags p Offset)
    (inst_data ty (InstructionData.Load (Opcode.Sload32x2) p MemFlags Offset))
)
(rule (sload32x2 ty MemFlags p Offset)
    (make_inst ty (InstructionData.Load (Opcode.Sload32x2) p MemFlags Offset))
)

(decl stack_load (Type StackSlot Offset32) Value)
(extractor
    (stack_load ty SS Offset)
    (inst_data ty (InstructionData.StackLoad (Opcode.StackLoad) SS Offset))
)
(rule (stack_load ty SS Offset)
    (make_inst ty (InstructionData.StackLoad (Opcode.StackLoad) SS Offset))
)

(decl stack_addr (Type StackSlot Offset32) Value)
(extractor
    (stack_addr ty SS Offset)
    (inst_data ty (InstructionData.StackLoad (Opcode.StackAddr) SS Offset))
)
(rule (stack_addr ty SS Offset)
    (make_inst ty (InstructionData.StackLoad (Opcode.StackAddr) SS Offset))
)

(decl dynamic_stack_load (Type DynamicStackSlot) Value)
(extractor
    (dynamic_stack_load ty DSS)
    (inst_data ty (InstructionData.DynamicStackLoad (Opcode.DynamicStackLoad) DSS))
)
(rule (dynamic_stack_load ty DSS)
    (make_inst ty (InstructionData.DynamicStackLoad (Opcode.DynamicStackLoad) DSS))
)

(decl dynamic_stack_addr (Type DynamicStackSlot) Value)
(extractor
    (dynamic_stack_addr ty DSS)
    (inst_data ty (InstructionData.DynamicStackLoad (Opcode.DynamicStackAddr) DSS))
)
(rule (dynamic_stack_addr ty DSS)
    (make_inst ty (InstructionData.DynamicStackLoad (Opcode.DynamicStackAddr) DSS))
)

(decl global_value (Type GlobalValue) Value)
(extractor
    (global_value ty GV)
    (inst_data ty (InstructionData.UnaryGlobalValue (Opcode.GlobalValue) GV))
)
(rule (global_value ty GV)
    (make_inst ty (InstructionData.UnaryGlobalValue (Opcode.GlobalValue) GV))
)

(decl symbol_value (Type GlobalValue) Value)
(extractor
    (symbol_value ty GV)
    (inst_data ty (InstructionData.UnaryGlobalValue (Opcode.SymbolValue) GV))
)
(rule (symbol_value ty GV)
    (make_inst ty (InstructionData.UnaryGlobalValue (Opcode.SymbolValue) GV))
)

(decl tls_value (Type GlobalValue) Value)
(extractor
    (tls_value ty GV)
    (inst_data ty (InstructionData.UnaryGlobalValue (Opcode.TlsValue) GV))
)
(rule (tls_value ty GV)
    (make_inst ty (InstructionData.UnaryGlobalValue (Opcode.TlsValue) GV))
)

(decl get_pinned_reg (Type ) Value)
(extractor
    (get_pinned_reg ty )
    (inst_data ty (InstructionData.NullAry (Opcode.GetPinnedReg)))
)
(rule (get_pinned_reg ty )
    (make_inst ty (InstructionData.NullAry (Opcode.GetPinnedReg)))
)

(decl get_frame_pointer (Type ) Value)
(extractor
    (get_frame_pointer ty )
    (inst_data ty (InstructionData.NullAry (Opcode.GetFramePointer)))
)
(rule (get_frame_pointer ty )
    (make_inst ty (InstructionData.NullAry (Opcode.GetFramePointer)))
)

(decl get_stack_pointer (Type ) Value)
(extractor
    (get_stack_pointer ty )
    (inst_data ty (InstructionData.NullAry (Opcode.GetStackPointer)))
)
(rule (get_stack_pointer ty )
    (make_inst ty (InstructionData.NullAry (Opcode.GetStackPointer)))
)

(decl get_return_address (Type ) Value)
(extractor
    (get_return_address ty )
    (inst_data ty (InstructionData.NullAry (Opcode.GetReturnAddress)))
)
(rule (get_return_address ty )
    (make_inst ty (InstructionData.NullAry (Opcode.GetReturnAddress)))
)

(decl iconst (Type Imm64) Value)
(extractor
    (iconst ty N)
    (inst_data ty (InstructionData.UnaryImm (Opcode.Iconst) N))
)
(rule (iconst ty N)
    (make_inst ty (InstructionData.UnaryImm (Opcode.Iconst) N))
)

(decl f16const (Type Ieee16) Value)
(extractor
    (f16const ty N)
    (inst_data ty (InstructionData.UnaryIeee16 (Opcode.F16const) N))
)
(rule (f16const ty N)
    (make_inst ty (InstructionData.UnaryIeee16 (Opcode.F16const) N))
)

(decl f32const (Type Ieee32) Value)
(extractor
    (f32const ty N)
    (inst_data ty (InstructionData.UnaryIeee32 (Opcode.F32const) N))
)
(rule (f32const ty N)
    (make_inst ty (InstructionData.UnaryIeee32 (Opcode.F32const) N))
)

(decl f64const (Type Ieee64) Value)
(extractor
    (f64const ty N)
    (inst_data ty (InstructionData.UnaryIeee64 (Opcode.F64const) N))
)
(rule (f64const ty N)
    (make_inst ty (InstructionData.UnaryIeee64 (Opcode.F64const) N))
)

(decl f128const (Type Constant) Value)
(extractor
    (f128const ty N)
    (inst_data ty (InstructionData.UnaryConst (Opcode.F128const) N))
)
(rule (f128const ty N)
    (make_inst ty (InstructionData.UnaryConst (Opcode.F128const) N))
)

(decl vconst (Type Constant) Value)
(extractor
    (vconst ty N)
    (inst_data ty (InstructionData.UnaryConst (Opcode.Vconst) N))
)
(rule (vconst ty N)
    (make_inst ty (InstructionData.UnaryConst (Opcode.Vconst) N))
)

(decl shuffle (Type Value Value Immediate) Value)
(extractor
    (shuffle ty a b mask)
    (inst_data ty (InstructionData.Shuffle (Opcode.Shuffle) (value_array_2 a b) mask))
)
(rule (shuffle ty a b mask)
    (make_inst ty (InstructionData.Shuffle (Opcode.Shuffle) (value_array_2_ctor a b) mask))
)

(decl select (Type Value Value Value) Value)
(extractor
    (select ty c x y)
    (inst_data ty (InstructionData.Ternary (Opcode.Select) (value_array_3 c x y)))
)
(rule (select ty c x y)
    (make_inst ty (InstructionData.Ternary (Opcode.Select) (value_array_3_ctor c x y)))
)

(decl select_spectre_guard (Type Value Value Value) Value)
(extractor
    (select_spectre_guard ty c x y)
    (inst_data ty (InstructionData.Ternary (Opcode.SelectSpectreGuard) (value_array_3 c x y)))
)
(rule (select_spectre_guard ty c x y)
    (make_inst ty (InstructionData.Ternary (Opcode.SelectSpectreGuard) (value_array_3_ctor c x y)))
)

(decl bitselect (Type Value Value Value) Value)
(extractor
    (bitselect ty c x y)
    (inst_data ty (InstructionData.Ternary (Opcode.Bitselect) (value_array_3 c x y)))
)
(rule (bitselect ty c x y)
    (make_inst ty (InstructionData.Ternary (Opcode.Bitselect) (value_array_3_ctor c x y)))
)

(decl x86_blendv (Type Value Value Value) Value)
(extractor
    (x86_blendv ty c x y)
    (inst_data ty (InstructionData.Ternary (Opcode.X86Blendv) (value_array_3 c x y)))
)
(rule (x86_blendv ty c x y)
    (make_inst ty (InstructionData.Ternary (Opcode.X86Blendv) (value_array_3_ctor c x y)))
)

(decl vany_true (Type Value) Value)
(extractor
    (vany_true ty a)
    (inst_data ty (InstructionData.Unary (Opcode.VanyTrue) a))
)
(rule (vany_true ty a)
    (make_inst ty (InstructionData.Unary (Opcode.VanyTrue) a))
)

(decl vall_true (Type Value) Value)
(extractor
    (vall_true ty a)
    (inst_data ty (InstructionData.Unary (Opcode.VallTrue) a))
)
(rule (vall_true ty a)
    (make_inst ty (InstructionData.Unary (Opcode.VallTrue) a))
)

(decl vhigh_bits (Type Value) Value)
(extractor
    (vhigh_bits ty a)
    (inst_data ty (InstructionData.Unary (Opcode.VhighBits) a))
)
(rule (vhigh_bits ty a)
    (make_inst ty (InstructionData.Unary (Opcode.VhighBits) a))
)

(decl icmp (Type IntCC Value Value) Value)
(extractor
    (icmp ty Cond x y)
    (inst_data ty (InstructionData.IntCompare (Opcode.Icmp) (value_array_2 x y) Cond))
)
(rule (icmp ty Cond x y)
    (make_inst ty (InstructionData.IntCompare (Opcode.Icmp) (value_array_2_ctor x y) Cond))
)

(decl icmp_imm (Type IntCC Value Imm64) Value)
(extractor
    (icmp_imm ty Cond x Y)
    (inst_data ty (InstructionData.IntCompareImm (Opcode.IcmpImm) x Cond Y))
)
(rule (icmp_imm ty Cond x Y)
    (make_inst ty (InstructionData.IntCompareImm (Opcode.IcmpImm) x Cond Y))
)

(decl iadd (Type Value Value) Value)
(extractor
    (iadd ty x y)
    (inst_data ty (InstructionData.Binary (Opcode.Iadd) (value_array_2 x y)))
)
(rule (iadd ty x y)
    (make_inst ty (InstructionData.Binary (Opcode.Iadd) (value_array_2_ctor x y)))
)

(decl isub (Type Value Value) Value)
(extractor
    (isub ty x y)
    (inst_data ty (InstructionData.Binary (Opcode.Isub) (value_array_2 x y)))
)
(rule (isub ty x y)
    (make_inst ty (InstructionData.Binary (Opcode.Isub) (value_array_2_ctor x y)))
)

(decl ineg (Type Value) Value)
(extractor
    (ineg ty x)
    (inst_data ty (InstructionData.Unary (Opcode.Ineg) x))
)
(rule (ineg ty x)
    (make_inst ty (InstructionData.Unary (Opcode.Ineg) x))
)

(decl iabs (Type Value) Value)
(extractor
    (iabs ty x)
    (inst_data ty (InstructionData.Unary (Opcode.Iabs) x))
)
(rule (iabs ty x)
    (make_inst ty (InstructionData.Unary (Opcode.Iabs) x))
)

(decl imul (Type Value Value) Value)
(extractor
    (imul ty x y)
    (inst_data ty (InstructionData.Binary (Opcode.Imul) (value_array_2 x y)))
)
(rule (imul ty x y)
    (make_inst ty (InstructionData.Binary (Opcode.Imul) (value_array_2_ctor x y)))
)

(decl umulhi (Type Value Value) Value)
(extractor
    (umulhi ty x y)
    (inst_data ty (InstructionData.Binary (Opcode.Umulhi) (value_array_2 x y)))
)
(rule (umulhi ty x y)
    (make_inst ty (InstructionData.Binary (Opcode.Umulhi) (value_array_2_ctor x y)))
)

(decl smulhi (Type Value Value) Value)
(extractor
    (smulhi ty x y)
    (inst_data ty (InstructionData.Binary (Opcode.Smulhi) (value_array_2 x y)))
)
(rule (smulhi ty x y)
    (make_inst ty (InstructionData.Binary (Opcode.Smulhi) (value_array_2_ctor x y)))
)

(decl sqmul_round_sat (Type Value Value) Value)
(extractor
    (sqmul_round_sat ty x y)
    (inst_data ty (InstructionData.Binary (Opcode.SqmulRoundSat) (value_array_2 x y)))
)
(rule (sqmul_round_sat ty x y)
    (make_inst ty (InstructionData.Binary (Opcode.SqmulRoundSat) (value_array_2_ctor x y)))
)

(decl x86_pmulhrsw (Type Value Value) Value)
(extractor
    (x86_pmulhrsw ty x y)
    (inst_data ty (InstructionData.Binary (Opcode.X86Pmulhrsw) (value_array_2 x y)))
)
(rule (x86_pmulhrsw ty x y)
    (make_inst ty (InstructionData.Binary (Opcode.X86Pmulhrsw) (value_array_2_ctor x y)))
)

(decl udiv (Type Value Value) Value)
(extractor
    (udiv ty x y)
    (inst_data ty (InstructionData.Binary (Opcode.Udiv) (value_array_2 x y)))
)
(rule (udiv ty x y)
    (make_inst ty (InstructionData.Binary (Opcode.Udiv) (value_array_2_ctor x y)))
)

(decl sdiv (Type Value Value) Value)
(extractor
    (sdiv ty x y)
    (inst_data ty (InstructionData.Binary (Opcode.Sdiv) (value_array_2 x y)))
)
(rule (sdiv ty x y)
    (make_inst ty (InstructionData.Binary (Opcode.Sdiv) (value_array_2_ctor x y)))
)

(decl urem (Type Value Value) Value)
(extractor
    (urem ty x y)
    (inst_data ty (InstructionData.Binary (Opcode.Urem) (value_array_2 x y)))
)
(rule (urem ty x y)
    (make_inst ty (InstructionData.Binary (Opcode.Urem) (value_array_2_ctor x y)))
)

(decl srem (Type Value Value) Value)
(extractor
    (srem ty x y)
    (inst_data ty (InstructionData.Binary (Opcode.Srem) (value_array_2 x y)))
)
(rule (srem ty x y)
    (make_inst ty (InstructionData.Binary (Opcode.Srem) (value_array_2_ctor x y)))
)

(decl iadd_imm (Type Value Imm64) Value)
(extractor
    (iadd_imm ty x Y)
    (inst_data ty (InstructionData.BinaryImm64 (Opcode.IaddImm) x Y))
)
(rule (iadd_imm ty x Y)
    (make_inst ty (InstructionData.BinaryImm64 (Opcode.IaddImm) x Y))
)

(decl imul_imm (Type Value Imm64) Value)
(extractor
    (imul_imm ty x Y)
    (inst_data ty (InstructionData.BinaryImm64 (Opcode.ImulImm) x Y))
)
(rule (imul_imm ty x Y)
    (make_inst ty (InstructionData.BinaryImm64 (Opcode.ImulImm) x Y))
)

(decl udiv_imm (Type Value Imm64) Value)
(extractor
    (udiv_imm ty x Y)
    (inst_data ty (InstructionData.BinaryImm64 (Opcode.UdivImm) x Y))
)
(rule (udiv_imm ty x Y)
    (make_inst ty (InstructionData.BinaryImm64 (Opcode.UdivImm) x Y))
)

(decl sdiv_imm (Type Value Imm64) Value)
(extractor
    (sdiv_imm ty x Y)
    (inst_data ty (InstructionData.BinaryImm64 (Opcode.SdivImm) x Y))
)
(rule (sdiv_imm ty x Y)
    (make_inst ty (InstructionData.BinaryImm64 (Opcode.SdivImm) x Y))
)

(decl urem_imm (Type Value Imm64) Value)
(extractor
    (urem_imm ty x Y)
    (inst_data ty (InstructionData.BinaryImm64 (Opcode.UremImm) x Y))
)
(rule (urem_imm ty x Y)
    (make_inst ty (InstructionData.BinaryImm64 (Opcode.UremImm) x Y))
)

(decl srem_imm (Type Value Imm64) Value)
(extractor
    (srem_imm ty x Y)
    (inst_data ty (InstructionData.BinaryImm64 (Opcode.SremImm) x Y))
)
(rule (srem_imm ty x Y)
    (make_inst ty (InstructionData.BinaryImm64 (Opcode.SremImm) x Y))
)

(decl irsub_imm (Type Value Imm64) Value)
(extractor
    (irsub_imm ty x Y)
    (inst_data ty (InstructionData.BinaryImm64 (Opcode.IrsubImm) x Y))
)
(rule (irsub_imm ty x Y)
    (make_inst ty (InstructionData.BinaryImm64 (Opcode.IrsubImm) x Y))
)

(decl uadd_overflow_trap (Type Value Value TrapCode) Value)
(extractor
    (uadd_overflow_trap ty x y code)
    (inst_data ty (InstructionData.IntAddTrap (Opcode.UaddOverflowTrap) (value_array_2 x y) code))
)
(rule (uadd_overflow_trap ty x y code)
    (make_inst ty (InstructionData.IntAddTrap (Opcode.UaddOverflowTrap) (value_array_2_ctor x y) code))
)

(decl band (Type Value Value) Value)
(extractor
    (band ty x y)
    (inst_data ty (InstructionData.Binary (Opcode.Band) (value_array_2 x y)))
)
(rule (band ty x y)
    (make_inst ty (InstructionData.Binary (Opcode.Band) (value_array_2_ctor x y)))
)

(decl bor (Type Value Value) Value)
(extractor
    (bor ty x y)
    (inst_data ty (InstructionData.Binary (Opcode.Bor) (value_array_2 x y)))
)
(rule (bor ty x y)
    (make_inst ty (InstructionData.Binary (Opcode.Bor) (value_array_2_ctor x y)))
)

(decl bxor (Type Value Value) Value)
(extractor
    (bxor ty x y)
    (inst_data ty (InstructionData.Binary (Opcode.Bxor) (value_array_2 x y)))
)
(rule (bxor ty x y)
    (make_inst ty (InstructionData.Binary (Opcode.Bxor) (value_array_2_ctor x y)))
)

(decl bnot (Type Value) Value)
(extractor
    (bnot ty x)
    (inst_data ty (InstructionData.Unary (Opcode.Bnot) x))
)
(rule (bnot ty x)
    (make_inst ty (InstructionData.Unary (Opcode.Bnot) x))
)

(decl band_not (Type Value Value) Value)
(extractor
    (band_not ty x y)
    (inst_data ty (InstructionData.Binary (Opcode.BandNot) (value_array_2 x y)))
)
(rule (band_not ty x y)
    (make_inst ty (InstructionData.Binary (Opcode.BandNot) (value_array_2_ctor x y)))
)

(decl bor_not (Type Value Value) Value)
(extractor
    (bor_not ty x y)
    (inst_data ty (InstructionData.Binary (Opcode.BorNot) (value_array_2 x y)))
)
(rule (bor_not ty x y)
    (make_inst ty (InstructionData.Binary (Opcode.BorNot) (value_array_2_ctor x y)))
)

(decl bxor_not (Type Value Value) Value)
(extractor
    (bxor_not ty x y)
    (inst_data ty (InstructionData.Binary (Opcode.BxorNot) (value_array_2 x y)))
)
(rule (bxor_not ty x y)
    (make_inst ty (InstructionData.Binary (Opcode.BxorNot) (value_array_2_ctor x y)))
)

(decl band_imm (Type Value Imm64) Value)
(extractor
    (band_imm ty x Y)
    (inst_data ty (InstructionData.BinaryImm64 (Opcode.BandImm) x Y))
)
(rule (band_imm ty x Y)
    (make_inst ty (InstructionData.BinaryImm64 (Opcode.BandImm) x Y))
)

(decl bor_imm (Type Value Imm64) Value)
(extractor
    (bor_imm ty x Y)
    (inst_data ty (InstructionData.BinaryImm64 (Opcode.BorImm) x Y))
)
(rule (bor_imm ty x Y)
    (make_inst ty (InstructionData.BinaryImm64 (Opcode.BorImm) x Y))
)

(decl bxor_imm (Type Value Imm64) Value)
(extractor
    (bxor_imm ty x Y)
    (inst_data ty (InstructionData.BinaryImm64 (Opcode.BxorImm) x Y))
)
(rule (bxor_imm ty x Y)
    (make_inst ty (InstructionData.BinaryImm64 (Opcode.BxorImm) x Y))
)

(decl rotl (Type Value Value) Value)
(extractor
    (rotl ty x y)
    (inst_data ty (InstructionData.Binary (Opcode.Rotl) (value_array_2 x y)))
)
(rule (rotl ty x y)
    (make_inst ty (InstructionData.Binary (Opcode.Rotl) (value_array_2_ctor x y)))
)

(decl rotr (Type Value Value) Value)
(extractor
    (rotr ty x y)
    (inst_data ty (InstructionData.Binary (Opcode.Rotr) (value_array_2 x y)))
)
(rule (rotr ty x y)
    (make_inst ty (InstructionData.Binary (Opcode.Rotr) (value_array_2_ctor x y)))
)

(decl rotl_imm (Type Value Imm64) Value)
(extractor
    (rotl_imm ty x Y)
    (inst_data ty (InstructionData.BinaryImm64 (Opcode.RotlImm) x Y))
)
(rule (rotl_imm ty x Y)
    (make_inst ty (InstructionData.BinaryImm64 (Opcode.RotlImm) x Y))
)

(decl rotr_imm (Type Value Imm64) Value)
(extractor
    (rotr_imm ty x Y)
    (inst_data ty (InstructionData.BinaryImm64 (Opcode.RotrImm) x Y))
)
(rule (rotr_imm ty x Y)
    (make_inst ty (InstructionData.BinaryImm64 (Opcode.RotrImm) x Y))
)

(decl ishl (Type Value Value) Value)
(extractor
    (ishl ty x y)
    (inst_data ty (InstructionData.Binary (Opcode.Ishl) (value_array_2 x y)))
)
(rule (ishl ty x y)
    (make_inst ty (InstructionData.Binary (Opcode.Ishl) (value_array_2_ctor x y)))
)

(decl ushr (Type Value Value) Value)
(extractor
    (ushr ty x y)
    (inst_data ty (InstructionData.Binary (Opcode.Ushr) (value_array_2 x y)))
)
(rule (ushr ty x y)
    (make_inst ty (InstructionData.Binary (Opcode.Ushr) (value_array_2_ctor x y)))
)

(decl sshr (Type Value Value) Value)
(extractor
    (sshr ty x y)
    (inst_data ty (InstructionData.Binary (Opcode.Sshr) (value_array_2 x y)))
)
(rule (sshr ty x y)
    (make_inst ty (InstructionData.Binary (Opcode.Sshr) (value_array_2_ctor x y)))
)

(decl ishl_imm (Type Value Imm64) Value)
(extractor
    (ishl_imm ty x Y)
    (inst_data ty (InstructionData.BinaryImm64 (Opcode.IshlImm) x Y))
)
(rule (ishl_imm ty x Y)
    (make_inst ty (InstructionData.BinaryImm64 (Opcode.IshlImm) x Y))
)

(decl ushr_imm (Type Value Imm64) Value)
(extractor
    (ushr_imm ty x Y)
    (inst_data ty (InstructionData.BinaryImm64 (Opcode.UshrImm) x Y))
)
(rule (ushr_imm ty x Y)
    (make_inst ty (InstructionData.BinaryImm64 (Opcode.UshrImm) x Y))
)

(decl sshr_imm (Type Value Imm64) Value)
(extractor
    (sshr_imm ty x Y)
    (inst_data ty (InstructionData.BinaryImm64 (Opcode.SshrImm) x Y))
)
(rule (sshr_imm ty x Y)
    (make_inst ty (InstructionData.BinaryImm64 (Opcode.SshrImm) x Y))
)

(decl bitrev (Type Value) Value)
(extractor
    (bitrev ty x)
    (inst_data ty (InstructionData.Unary (Opcode.Bitrev) x))
)
(rule (bitrev ty x)
    (make_inst ty (InstructionData.Unary (Opcode.Bitrev) x))
)

(decl clz (Type Value) Value)
(extractor
    (clz ty x)
    (inst_data ty (InstructionData.Unary (Opcode.Clz) x))
)
(rule (clz ty x)
    (make_inst ty (InstructionData.Unary (Opcode.Clz) x))
)

(decl cls (Type Value) Value)
(extractor
    (cls ty x)
    (inst_data ty (InstructionData.Unary (Opcode.Cls) x))
)
(rule (cls ty x)
    (make_inst ty (InstructionData.Unary (Opcode.Cls) x))
)

(decl ctz (Type Value) Value)
(extractor
    (ctz ty x)
    (inst_data ty (InstructionData.Unary (Opcode.Ctz) x))
)
(rule (ctz ty x)
    (make_inst ty (InstructionData.Unary (Opcode.Ctz) x))
)

(decl bswap (Type Value) Value)
(extractor
    (bswap ty x)
    (inst_data ty (InstructionData.Unary (Opcode.Bswap) x))
)
(rule (bswap ty x)
    (make_inst ty (InstructionData.Unary (Opcode.Bswap) x))
)

(decl popcnt (Type Value) Value)
(extractor
    (popcnt ty x)
    (inst_data ty (InstructionData.Unary (Opcode.Popcnt) x))
)
(rule (popcnt ty x)
    (make_inst ty (InstructionData.Unary (Opcode.Popcnt) x))
)

(decl fcmp (Type FloatCC Value Value) Value)
(extractor
    (fcmp ty Cond x y)
    (inst_data ty (InstructionData.FloatCompare (Opcode.Fcmp) (value_array_2 x y) Cond))
)
(rule (fcmp ty Cond x y)
    (make_inst ty (InstructionData.FloatCompare (Opcode.Fcmp) (value_array_2_ctor x y) Cond))
)

(decl fadd (Type Value Value) Value)
(extractor
    (fadd ty x y)
    (inst_data ty (InstructionData.Binary (Opcode.Fadd) (value_array_2 x y)))
)
(rule (fadd ty x y)
    (make_inst ty (InstructionData.Binary (Opcode.Fadd) (value_array_2_ctor x y)))
)

(decl fsub (Type Value Value) Value)
(extractor
    (fsub ty x y)
    (inst_data ty (InstructionData.Binary (Opcode.Fsub) (value_array_2 x y)))
)
(rule (fsub ty x y)
    (make_inst ty (InstructionData.Binary (Opcode.Fsub) (value_array_2_ctor x y)))
)

(decl fmul (Type Value Value) Value)
(extractor
    (fmul ty x y)
    (inst_data ty (InstructionData.Binary (Opcode.Fmul) (value_array_2 x y)))
)
(rule (fmul ty x y)
    (make_inst ty (InstructionData.Binary (Opcode.Fmul) (value_array_2_ctor x y)))
)

(decl fdiv (Type Value Value) Value)
(extractor
    (fdiv ty x y)
    (inst_data ty (InstructionData.Binary (Opcode.Fdiv) (value_array_2 x y)))
)
(rule (fdiv ty x y)
    (make_inst ty (InstructionData.Binary (Opcode.Fdiv) (value_array_2_ctor x y)))
)

(decl sqrt (Type Value) Value)
(extractor
    (sqrt ty x)
    (inst_data ty (InstructionData.Unary (Opcode.Sqrt) x))
)
(rule (sqrt ty x)
    (make_inst ty (InstructionData.Unary (Opcode.Sqrt) x))
)

(decl fma (Type Value Value Value) Value)
(extractor
    (fma ty x y z)
    (inst_data ty (InstructionData.Ternary (Opcode.Fma) (value_array_3 x y z)))
)
(rule (fma ty x y z)
    (make_inst ty (InstructionData.Ternary (Opcode.Fma) (value_array_3_ctor x y z)))
)

(decl fneg (Type Value) Value)
(extractor
    (fneg ty x)
    (inst_data ty (InstructionData.Unary (Opcode.Fneg) x))
)
(rule (fneg ty x)
    (make_inst ty (InstructionData.Unary (Opcode.Fneg) x))
)

(decl fabs (Type Value) Value)
(extractor
    (fabs ty x)
    (inst_data ty (InstructionData.Unary (Opcode.Fabs) x))
)
(rule (fabs ty x)
    (make_inst ty (InstructionData.Unary (Opcode.Fabs) x))
)

(decl fcopysign (Type Value Value) Value)
(extractor
    (fcopysign ty x y)
    (inst_data ty (InstructionData.Binary (Opcode.Fcopysign) (value_array_2 x y)))
)
(rule (fcopysign ty x y)
    (make_inst ty (InstructionData.Binary (Opcode.Fcopysign) (value_array_2_ctor x y)))
)

(decl fmin (Type Value Value) Value)
(extractor
    (fmin ty x y)
    (inst_data ty (InstructionData.Binary (Opcode.Fmin) (value_array_2 x y)))
)
(rule (fmin ty x y)
    (make_inst ty (InstructionData.Binary (Opcode.Fmin) (value_array_2_ctor x y)))
)

(decl fmax (Type Value Value) Value)
(extractor
    (fmax ty x y)
    (inst_data ty (InstructionData.Binary (Opcode.Fmax) (value_array_2 x y)))
)
(rule (fmax ty x y)
    (make_inst ty (InstructionData.Binary (Opcode.Fmax) (value_array_2_ctor x y)))
)

(decl ceil (Type Value) Value)
(extractor
    (ceil ty x)
    (inst_data ty (InstructionData.Unary (Opcode.Ceil) x))
)
(rule (ceil ty x)
    (make_inst ty (InstructionData.Unary (Opcode.Ceil) x))
)

(decl floor (Type Value) Value)
(extractor
    (floor ty x)
    (inst_data ty (InstructionData.Unary (Opcode.Floor) x))
)
(rule (floor ty x)
    (make_inst ty (InstructionData.Unary (Opcode.Floor) x))
)

(decl trunc (Type Value) Value)
(extractor
    (trunc ty x)
    (inst_data ty (InstructionData.Unary (Opcode.Trunc) x))
)
(rule (trunc ty x)
    (make_inst ty (InstructionData.Unary (Opcode.Trunc) x))
)

(decl nearest (Type Value) Value)
(extractor
    (nearest ty x)
    (inst_data ty (InstructionData.Unary (Opcode.Nearest) x))
)
(rule (nearest ty x)
    (make_inst ty (InstructionData.Unary (Opcode.Nearest) x))
)

(decl bitcast (Type MemFlags Value) Value)
(extractor
    (bitcast ty MemFlags x)
    (inst_data ty (InstructionData.LoadNoOffset (Opcode.Bitcast) x MemFlags))
)
(rule (bitcast ty MemFlags x)
    (make_inst ty (InstructionData.LoadNoOffset (Opcode.Bitcast) x MemFlags))
)

(decl scalar_to_vector (Type Value) Value)
(extractor
    (scalar_to_vector ty s)
    (inst_data ty (InstructionData.Unary (Opcode.ScalarToVector) s))
)
(rule (scalar_to_vector ty s)
    (make_inst ty (InstructionData.Unary (Opcode.ScalarToVector) s))
)

(decl bmask (Type Value) Value)
(extractor
    (bmask ty x)
    (inst_data ty (InstructionData.Unary (Opcode.Bmask) x))
)
(rule (bmask ty x)
    (make_inst ty (InstructionData.Unary (Opcode.Bmask) x))
)

(decl ireduce (Type Value) Value)
(extractor
    (ireduce ty x)
    (inst_data ty (InstructionData.Unary (Opcode.Ireduce) x))
)
(rule (ireduce ty x)
    (make_inst ty (InstructionData.Unary (Opcode.Ireduce) x))
)

(decl snarrow (Type Value Value) Value)
(extractor
    (snarrow ty x y)
    (inst_data ty (InstructionData.Binary (Opcode.Snarrow) (value_array_2 x y)))
)
(rule (snarrow ty x y)
    (make_inst ty (InstructionData.Binary (Opcode.Snarrow) (value_array_2_ctor x y)))
)

(decl unarrow (Type Value Value) Value)
(extractor
    (unarrow ty x y)
    (inst_data ty (InstructionData.Binary (Opcode.Unarrow) (value_array_2 x y)))
)
(rule (unarrow ty x y)
    (make_inst ty (InstructionData.Binary (Opcode.Unarrow) (value_array_2_ctor x y)))
)

(decl uunarrow (Type Value Value) Value)
(extractor
    (uunarrow ty x y)
    (inst_data ty (InstructionData.Binary (Opcode.Uunarrow) (value_array_2 x y)))
)
(rule (uunarrow ty x y)
    (make_inst ty (InstructionData.Binary (Opcode.Uunarrow) (value_array_2_ctor x y)))
)

(decl swiden_low (Type Value) Value)
(extractor
    (swiden_low ty x)
    (inst_data ty (InstructionData.Unary (Opcode.SwidenLow) x))
)
(rule (swiden_low ty x)
    (make_inst ty (InstructionData.Unary (Opcode.SwidenLow) x))
)

(decl swiden_high (Type Value) Value)
(extractor
    (swiden_high ty x)
    (inst_data ty (InstructionData.Unary (Opcode.SwidenHigh) x))
)
(rule (swiden_high ty x)
    (make_inst ty (InstructionData.Unary (Opcode.SwidenHigh) x))
)

(decl uwiden_low (Type Value) Value)
(extractor
    (uwiden_low ty x)
    (inst_data ty (InstructionData.Unary (Opcode.UwidenLow) x))
)
(rule (uwiden_low ty x)
    (make_inst ty (InstructionData.Unary (Opcode.UwidenLow) x))
)

(decl uwiden_high (Type Value) Value)
(extractor
    (uwiden_high ty x)
    (inst_data ty (InstructionData.Unary (Opcode.UwidenHigh) x))
)
(rule (uwiden_high ty x)
    (make_inst ty (InstructionData.Unary (Opcode.UwidenHigh) x))
)

(decl iadd_pairwise (Type Value Value) Value)
(extractor
    (iadd_pairwise ty x y)
    (inst_data ty (InstructionData.Binary (Opcode.IaddPairwise) (value_array_2 x y)))
)
(rule (iadd_pairwise ty x y)
    (make_inst ty (InstructionData.Binary (Opcode.IaddPairwise) (value_array_2_ctor x y)))
)

(decl x86_pmaddubsw (Type Value Value) Value)
(extractor
    (x86_pmaddubsw ty x y)
    (inst_data ty (InstructionData.Binary (Opcode.X86Pmaddubsw) (value_array_2 x y)))
)
(rule (x86_pmaddubsw ty x y)
    (make_inst ty (InstructionData.Binary (Opcode.X86Pmaddubsw) (value_array_2_ctor x y)))
)

(decl uextend (Type Value) Value)
(extractor
    (uextend ty x)
    (inst_data ty (InstructionData.Unary (Opcode.Uextend) x))
)
(rule (uextend ty x)
    (make_inst ty (InstructionData.Unary (Opcode.Uextend) x))
)

(decl sextend (Type Value) Value)
(extractor
    (sextend ty x)
    (inst_data ty (InstructionData.Unary (Opcode.Sextend) x))
)
(rule (sextend ty x)
    (make_inst ty (InstructionData.Unary (Opcode.Sextend) x))
)

(decl fpromote (Type Value) Value)
(extractor
    (fpromote ty x)
    (inst_data ty (InstructionData.Unary (Opcode.Fpromote) x))
)
(rule (fpromote ty x)
    (make_inst ty (InstructionData.Unary (Opcode.Fpromote) x))
)

(decl fdemote (Type Value) Value)
(extractor
    (fdemote ty x)
    (inst_data ty (InstructionData.Unary (Opcode.Fdemote) x))
)
(rule (fdemote ty x)
    (make_inst ty (InstructionData.Unary (Opcode.Fdemote) x))
)

(decl fvdemote (Type Value) Value)
(extractor
    (fvdemote ty x)
    (inst_data ty (InstructionData.Unary (Opcode.Fvdemote) x))
)
(rule (fvdemote ty x)
    (make_inst ty (InstructionData.Unary (Opcode.Fvdemote) x))
)

(decl fvpromote_low (Type Value) Value)
(extractor
    (fvpromote_low ty a)
    (inst_data ty (InstructionData.Unary (Opcode.FvpromoteLow) a))
)
(rule (fvpromote_low ty a)
    (make_inst ty (InstructionData.Unary (Opcode.FvpromoteLow) a))
)

(decl fcvt_to_uint (Type Value) Value)
(extractor
    (fcvt_to_uint ty x)
    (inst_data ty (InstructionData.Unary (Opcode.FcvtToUint) x))
)
(rule (fcvt_to_uint ty x)
    (make_inst ty (InstructionData.Unary (Opcode.FcvtToUint) x))
)

(decl fcvt_to_sint (Type Value) Value)
(extractor
    (fcvt_to_sint ty x)
    (inst_data ty (InstructionData.Unary (Opcode.FcvtToSint) x))
)
(rule (fcvt_to_sint ty x)
    (make_inst ty (InstructionData.Unary (Opcode.FcvtToSint) x))
)

(decl fcvt_to_uint_sat (Type Value) Value)
(extractor
    (fcvt_to_uint_sat ty x)
    (inst_data ty (InstructionData.Unary (Opcode.FcvtToUintSat) x))
)
(rule (fcvt_to_uint_sat ty x)
    (make_inst ty (InstructionData.Unary (Opcode.FcvtToUintSat) x))
)

(decl fcvt_to_sint_sat (Type Value) Value)
(extractor
    (fcvt_to_sint_sat ty x)
    (inst_data ty (InstructionData.Unary (Opcode.FcvtToSintSat) x))
)
(rule (fcvt_to_sint_sat ty x)
    (make_inst ty (InstructionData.Unary (Opcode.FcvtToSintSat) x))
)

(decl x86_cvtt2dq (Type Value) Value)
(extractor
    (x86_cvtt2dq ty x)
    (inst_data ty (InstructionData.Unary (Opcode.X86Cvtt2dq) x))
)
(rule (x86_cvtt2dq ty x)
    (make_inst ty (InstructionData.Unary (Opcode.X86Cvtt2dq) x))
)

(decl fcvt_from_uint (Type Value) Value)
(extractor
    (fcvt_from_uint ty x)
    (inst_data ty (InstructionData.Unary (Opcode.FcvtFromUint) x))
)
(rule (fcvt_from_uint ty x)
    (make_inst ty (InstructionData.Unary (Opcode.FcvtFromUint) x))
)

(decl fcvt_from_sint (Type Value) Value)
(extractor
    (fcvt_from_sint ty x)
    (inst_data ty (InstructionData.Unary (Opcode.FcvtFromSint) x))
)
(rule (fcvt_from_sint ty x)
    (make_inst ty (InstructionData.Unary (Opcode.FcvtFromSint) x))
)

(decl iconcat (Type Value Value) Value)
(extractor
    (iconcat ty lo hi)
    (inst_data ty (InstructionData.Binary (Opcode.Iconcat) (value_array_2 lo hi)))
)
(rule (iconcat ty lo hi)
    (make_inst ty (InstructionData.Binary (Opcode.Iconcat) (value_array_2_ctor lo hi)))
)

(decl atomic_rmw (Type MemFlags AtomicRmwOp Value Value) Value)
(extractor
    (atomic_rmw ty MemFlags AtomicRmwOp p x)
    (inst_data ty (InstructionData.AtomicRmw (Opcode.AtomicRmw) (value_array_2 p x) MemFlags AtomicRmwOp))
)
(rule (atomic_rmw ty MemFlags AtomicRmwOp p x)
    (make_inst ty (InstructionData.AtomicRmw (Opcode.AtomicRmw) (value_array_2_ctor p x) MemFlags AtomicRmwOp))
)

(decl atomic_cas (Type MemFlags Value Value Value) Value)
(extractor
    (atomic_cas ty MemFlags p e x)
    (inst_data ty (InstructionData.AtomicCas (Opcode.AtomicCas) (value_array_3 p e x) MemFlags))
)
(rule (atomic_cas ty MemFlags p e x)
    (make_inst ty (InstructionData.AtomicCas (Opcode.AtomicCas) (value_array_3_ctor p e x) MemFlags))
)

(decl atomic_load (Type MemFlags Value) Value)
(extractor
    (atomic_load ty MemFlags p)
    (inst_data ty (InstructionData.LoadNoOffset (Opcode.AtomicLoad) p MemFlags))
)
(rule (atomic_load ty MemFlags p)
    (make_inst ty (InstructionData.LoadNoOffset (Opcode.AtomicLoad) p MemFlags))
)

(decl extract_vector (Type Value Uimm8) Value)
(extractor
    (extract_vector ty x y)
    (inst_data ty (InstructionData.BinaryImm8 (Opcode.ExtractVector) x y))
)
(rule (extract_vector ty x y)
    (make_inst ty (InstructionData.BinaryImm8 (Opcode.ExtractVector) x y))
)