/* ************************************************************************
 * Copyright (C) 2025-2026 Advanced Micro Devices, Inc.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 *
 * ************************************************************************ */

/**
 * @file IRInstructionDefs.inc
 * @brief High-Level IR Instruction Definitions
 *
 * This file contains all high-level IR instruction definitions used by
 * GenHighLevelIR.cpp to generate IR instruction classes.
 *
 * Each instruction is defined as an IRInstDef with the following parameters:
 *   1. className    - C++ class name (e.g., "VAddF32")
 *   2. comment      - Instruction description
 *   3. numSrcs      - Number of source operands
 *   4. hasDest      - Whether it has a destination operand
 *   5. category     - Instruction category (e.g., "Vector Arithmetic")
 *   6. supportsDPP  - Whether it supports DPP modifiers
 *   7. supportsSDWA - Whether it supports SDWA modifiers
 *   8. hasDS        - Whether it has DS (LDS) modifiers
 *   9. flags        - Instruction flags (optional 10th: numRequiredSrcs)
 *
 * Logical IR has no mnemonics; ASM mnemonic is per-arch (LogicalToAsmMappings_generated.inc).
 *
 * This file is included by getIRInstructions() in GenHighLevelIR.cpp.
 * Do not include this file directly elsewhere.
 */

                                    {"VAddU32",
             "VAddU32",
             2,
             true,
             "Vector Arithmetic",
             true,
             true,
             false,
             "IF_Commutative|IF_VALU"},

                                    {"VMulF32",
             "VMulF32",
             2,
             true,
             "Vector Arithmetic",
             true,
             true,
             false,
             "IF_Commutative|IF_VALU"},

                                    {"VAddF16",
             "VAddF16",
             2,
             true,
             "Vector Arithmetic",
             true,
             true,
             false,
             "IF_Commutative|IF_VALU"},

                                    {"VAddF32",
             "VAddF32",
             2,
             true,
             "Vector Arithmetic",
             true,
             true,
             false,
             "IF_Commutative|IF_VALU"},

                                    {"VAddF64",
             "VAddF64",
             2,
             true,
             "Vector Arithmetic",
             true,
             true,
             false,
             "IF_Commutative|IF_VALU"},

                                    {"VAddI32",
             "VAddI32",
             2,
             true,
             "Vector Arithmetic",
             true,
             true,
             false,
             "IF_Commutative|IF_VALU"},

                                    {"VAddCOU32",
             "VAddCOU32",
             2,
             true,
             "Vector Arithmetic",
             true,
             true,
             false,
             "IF_Commutative|IF_VALU"},

                                    {"VAddCCOU32",
             "VAddCCOU32",
             2,
             true,
             "Vector Arithmetic",
             true,
             true,
             false,
             "IF_Commutative|IF_VALU"},

                                    {"VAddPKF16",
             "VAddPKF16",
             2,
             true,
             "Vector Arithmetic",
             true,
             true,
             false,
             "IF_Commutative|IF_VALU"},

                                    {"VAdd3U32",
             "VAdd3U32",
             2,
             true,
             "Vector Arithmetic",
             true,
             true,
             false,
             "IF_Commutative|IF_VALU"},

                                    {"VSubF32",
             "VSubF32",
             2,
             true,
             "Vector Arithmetic",
             true,
             true,
             false,
             "IF_VALU"},

                                    {"VSubI32",
             "VSubI32",
             2,
             true,
             "Vector Arithmetic",
             true,
             true,
             false,
             "IF_VALU"},

                                    {"VSubU32",
             "VSubU32",
             2,
             true,
             "Vector Arithmetic",
             true,
             true,
             false,
             "IF_VALU"},

                                    {"VSubCoU32",
             "VSubCoU32",
             2,
             true,
             "Vector Arithmetic",
             true,
             true,
             false,
             "IF_VALU"},

                                    {"VMulF16",
             "VMulF16",
             2,
             true,
             "Vector Arithmetic",
             true,
             true,
             false,
             "IF_Commutative|IF_VALU"},

                                    {"VMulF64",
             "VMulF64",
             2,
             true,
             "Vector Arithmetic",
             true,
             true,
             false,
             "IF_Commutative|IF_VALU"},

                                    {"VMulPKF16",
             "VMulPKF16",
             2,
             true,
             "Vector Arithmetic",
             true,
             true,
             false,
             "IF_Commutative|IF_VALU"},

                                    {"VMulPKF32S",
             "VMulPKF32S",
             2,
             true,
             "Vector Arithmetic",
             true,
             true,
             false,
             "IF_Commutative|IF_VALU"},

                                    {"VMulLOU32",
             "VMulLOU32",
             2,
             true,
             "Vector Arithmetic",
             true,
             true,
             false,
             "IF_Commutative|IF_VALU"},

                                    {"VMulHII32",
             "VMulHII32",
             2,
             true,
             "Vector Arithmetic",
             true,
             true,
             false,
             "IF_Commutative|IF_VALU"},

                                    {"VMulHIU32",
             "VMulHIU32",
             2,
             true,
             "Vector Arithmetic",
             true,
             true,
             false,
             "IF_Commutative|IF_VALU"},

                                    {"VMulI32I24",
             "VMulI32I24",
             2,
             true,
             "Vector Arithmetic",
             true,
             true,
             false,
             "IF_Commutative|IF_VALU"},

                                    {"VMulU32U24",
             "VMulU32U24",
             2,
             true,
             "Vector Arithmetic",
             true,
             true,
             false,
             "IF_Commutative|IF_VALU"},

                                    {"VMacF32",
             "VMacF32",
             2,
             true,
             "Vector Arithmetic",
             true,
             true,
             false,
             "IF_VALU"},

                                    {"VFmaF16",
             "VFmaF16",
             3,
             true,
             "Vector Arithmetic",
             true,
             true,
             false,
             "IF_Commutative|IF_VALU"},

                                    {"VFmaF32",
             "VFmaF32",
             3,
             true,
             "Vector Arithmetic",
             true,
             true,
             false,
             "IF_Commutative|IF_VALU"},

                                    {"VFmaF64",
             "VFmaF64",
             3,
             true,
             "Vector Arithmetic",
             true,
             true,
             false,
             "IF_Commutative|IF_VALU"},

                                    {"VFmaPKF16",
             "VFmaPKF16",
             3,
             true,
             "Vector Arithmetic",
             true,
             true,
             false,
             "IF_Commutative|IF_VALU"},

                                                {"VFmaMixF32",
             "VFmaMixF32",
             3,
             true,
             "Vector Arithmetic",
             true,
             true,
             false,
             "IF_Commutative|IF_VALU"},

                                    {"VMadI32I24",
             "VMadI32I24",
             3,
             true,
             "Vector Arithmetic",
             true,
             true,
             false,
             "IF_VALU"},

                                    {"VMadU32U24",
             "VMadU32U24",
             3,
             true,
             "Vector Arithmetic",
             true,
             true,
             false,
             "IF_VALU"},

                                    {"VMadMixF32",
             "VMadMixF32",
             3,
             true,
             "Vector Arithmetic",
             true,
             true,
             false,
             "IF_VALU"},

                                    {"VDot2CF32F16",
             "VDot2CF32F16",
             3,
             true,
             "Vector Other",
             true,
             true,
             false,
             "IF_Commutative|IF_VALU"},

                                    {"VDot2F32F16",
             "VDot2F32F16",
             3,
             true,
             "Vector Other",
             true,
             true,
             false,
             "IF_Commutative|IF_VALU"},

                                    {"VDot2F32BF16",
             "VDot2F32BF16",
             3,
             true,
             "Vector Other",
             true,
             true,
             false,
             "IF_Commutative|IF_VALU"},

                                    {"VDot2CF32BF16",
             "VDot2CF32BF16",
             3,
             true,
             "Vector Other",
             true,
             true,
             false,
             "IF_Commutative|IF_VALU"},

                                                {"VExpF16",
             "VExpF16",
             1,
             true,
             "Vector Transcendental",
             true,
             true,
             false,
             "IF_Transcendental|IF_VALU"},

                                                {"VExpF32",
             "VExpF32",
             1,
             true,
             "Vector Transcendental",
             true,
             true,
             false,
             "IF_Transcendental|IF_VALU"},

                                                {"VRcpF16",
             "VRcpF16",
             1,
             true,
             "Vector Transcendental",
             true,
             true,
             false,
             "IF_Transcendental|IF_VALU"},

                                                {"VRcpF32",
             "VRcpF32",
             1,
             true,
             "Vector Transcendental",
             true,
             true,
             false,
             "IF_Transcendental|IF_VALU"},

                                                {"VRcpIFlagF32",
             "VRcpIFlagF32",
             1,
             true,
             "Vector Transcendental",
             true,
             true,
             false,
             "IF_Transcendental|IF_VALU"},

                                                {"VRsqF16",
             "VRsqF16",
             1,
             true,
             "Vector Transcendental",
             true,
             true,
             false,
             "IF_Transcendental|IF_VALU"},

                                                {"VRsqF32",
             "VRsqF32",
             1,
             true,
             "Vector Transcendental",
             true,
             true,
             false,
             "IF_Transcendental|IF_VALU"},

                                                {"VRsqIFlagF32",
             "VRsqIFlagF32",
             1,
             true,
             "Vector Transcendental",
             true,
             true,
             false,
             "IF_Transcendental|IF_VALU"},

                                    {"VRndneF32",
             "VRndneF32",
             1,
             true,
             "Vector Transcendental",
             true,
             true,
             false,
             "IF_VALU"},

                                    {"VMaxF16",
             "VMaxF16",
             2,
             true,
             "Vector MinMax",
             true,
             true,
             false,
             "IF_Commutative|IF_VALU"},

                                    {"VMaxF32",
             "VMaxF32",
             2,
             true,
             "Vector MinMax",
             true,
             true,
             false,
             "IF_Commutative|IF_VALU"},

                                    {"VMaxF64",
             "VMaxF64",
             2,
             true,
             "Vector MinMax",
             true,
             true,
             false,
             "IF_Commutative|IF_VALU"},

                                    {"VMaxI32",
             "VMaxI32",
             2,
             true,
             "Vector MinMax",
             true,
             true,
             false,
             "IF_Commutative|IF_VALU"},

                                    {"VMaxPKF16",
             "VMaxPKF16",
             2,
             true,
             "Vector MinMax",
             true,
             true,
             false,
             "IF_Commutative|IF_VALU"},

                                    {"VMinF16",
             "VMinF16",
             2,
             true,
             "Vector MinMax",
             true,
             true,
             false,
             "IF_Commutative|IF_VALU"},

                                    {"VMinF32",
             "VMinF32",
             2,
             true,
             "Vector MinMax",
             true,
             true,
             false,
             "IF_Commutative|IF_VALU"},

                                    {"VMinF64",
             "VMinF64",
             2,
             true,
             "Vector MinMax",
             true,
             true,
             false,
             "IF_Commutative|IF_VALU"},

                                    {"VMinI32",
             "VMinI32",
             2,
             true,
             "Vector MinMax",
             true,
             true,
             false,
             "IF_Commutative|IF_VALU"},

                                    {"VMed3I32",
             "VMed3I32",
             3,
             true,
             "Vector MinMax",
             true,
             true,
             false,
             "IF_VALU"},

                                    {"VMed3F32",
             "VMed3F32",
             3,
             true,
             "Vector MinMax",
             true,
             true,
             false,
             "IF_VALU"},

                                    {"VAndB32",
             "VAndB32",
             2,
             true,
             "Vector Bitwise",
             true,
             true,
             false,
             "IF_Commutative|IF_VALU"},

                                                {"VAndOrB32",
             "VAndOrB32",
             3,
             true,
             "Vector Bitwise",
             true,
             true,
             false,
             "IF_Commutative|IF_VALU"},

                                    {"VOrB32",
             "VOrB32",
             2,
             true,
             "Vector Bitwise",
             true,
             true,
             false,
             "IF_Commutative|IF_VALU"},

                                    {"VXorB32",
             "VXorB32",
             2,
             true,
             "Vector Bitwise",
             true,
             true,
             false,
             "IF_Commutative|IF_VALU"},

                                    {"VNotB32",
             "VNotB32",
             1,
             true,
             "Vector Bitwise",
             true,
             true,
             false,
             "IF_VALU"},

                                    {"VPrngB32",
             "VPrngB32",
             1,
             true,
             "Vector Other",
             true,
             true,
             false,
             "IF_VALU"},

                                    {"VCndMaskB32",
             "VCndMaskB32",
             2,
             true,
             "Vector Other",
             true,
             true,
             false,
             "IF_VALU"},

                                    {"VLShiftLeftB16",
             "VLShiftLeftB16",
             2,
             true,
             "Vector Shift",
             true,
             true,
             false,
             "IF_VALU"},

                                    {"VLShiftLeftB32",
             "VLShiftLeftB32",
             2,
             true,
             "Vector Shift",
             true,
             true,
             false,
             "IF_VALU"},

                                    {"VLShiftRightB32",
             "VLShiftRightB32",
             2,
             true,
             "Vector Shift",
             true,
             true,
             false,
             "IF_VALU"},

                                    {"VLShiftLeftB64",
             "VLShiftLeftB64",
             2,
             true,
             "Vector Shift",
             true,
             true,
             false,
             "IF_VALU"},

                                    {"VLShiftRightB64",
             "VLShiftRightB64",
             2,
             true,
             "Vector Shift",
             true,
             true,
             false,
             "IF_VALU"},

                                    {"VAShiftRightI32",
             "VAShiftRightI32",
             2,
             true,
             "Vector Shift",
             true,
             true,
             false,
             "IF_VALU"},

                                    {"VMovB32",
             "VMovB32",
             1,
             true,
             "Vector Move",
             false,
             false,
             false,
             "IF_VALU"},

                                    {"VSwapB32",
             "VSwapB32",
             1,
             true,
             "Vector Move",
             true,
             true,
             false,
             "IF_VALU"},

                                    {"VPackF16toB32",
             "VPackF16toB32",
             2,
             true,
             "Vector Move",
             true,
             true,
             false,
             "IF_VALU"},

                                    {"VPermB32",
             "VPermB32",
             3,
             true,
             "Vector Shift",
             true,
             true,
             false,
             "IF_VALU"},

                                    {"VBfeI32",
             "VBfeI32",
             3,
             true,
             "Vector Other",
             true,
             true,
             false,
             "IF_VALU"},

                                    {"VBfeU32",
             "VBfeU32",
             3,
             true,
             "Vector Other",
             true,
             true,
             false,
             "IF_VALU"},

                                    {"VBfiB32",
             "VBfiB32",
             3,
             true,
             "Vector Other",
             true,
             true,
             false,
             "IF_VALU"},

                                    {"VAccvgprReadB32",
             "VAccvgprReadB32",
             1,
             true,
             "Vector Other",
             false,
             false,
             false,
             "IF_VALU"},

                                    {"VAccvgprWrite",
             "VAccvgprWrite",
             1,
             true,
             "Vector Other",
             false,
             false,
             false,
             "IF_VALU"},

                                    {"VAccvgprWriteB32",
             "VAccvgprWriteB32",
             1,
             true,
             "Vector Other",
             false,
             false,
             false,
             "IF_VALU"},

                                    {"VReadfirstlaneB32",
             "VReadfirstlaneB32",
             1,
             true,
             "Vector Other",
             false,
             false,
             false,
             "IF_VALU"},

                                    {"SCmpEQI32",
             "SCmpEQI32",
             2,
             false,
             "Scalar Compare",
             false,
             false,
             false,
             "IF_SALU"},

                                    {"SCmpEQU32",
             "SCmpEQU32",
             2,
             false,
             "Scalar Compare",
             false,
             false,
             false,
             "IF_SALU"},

                                    {"SCmpEQU64",
             "SCmpEQU64",
             2,
             false,
             "Scalar Compare",
             false,
             false,
             false,
             "IF_SALU"},

                                    {"SCmpGeI32",
             "SCmpGeI32",
             2,
             false,
             "Scalar Compare",
             false,
             false,
             false,
             "IF_SALU"},

                                    {"SCmpGeU32",
             "SCmpGeU32",
             2,
             false,
             "Scalar Compare",
             false,
             false,
             false,
             "IF_SALU"},

                                    {"SCmpGtI32",
             "SCmpGtI32",
             2,
             false,
             "Scalar Compare",
             false,
             false,
             false,
             "IF_SALU"},

                                    {"SCmpGtU32",
             "SCmpGtU32",
             2,
             false,
             "Scalar Compare",
             false,
             false,
             false,
             "IF_SALU"},

                                    {"SCmpLeI32",
             "SCmpLeI32",
             2,
             false,
             "Scalar Compare",
             false,
             false,
             false,
             "IF_SALU"},

                                    {"SCmpLeU32",
             "SCmpLeU32",
             2,
             false,
             "Scalar Compare",
             false,
             false,
             false,
             "IF_SALU"},

                                    {"SCmpLgU32",
             "SCmpLgU32",
             2,
             false,
             "Scalar Compare",
             false,
             false,
             false,
             "IF_SALU"},

                                    {"SCmpLgI32",
             "SCmpLgI32",
             2,
             false,
             "Scalar Compare",
             false,
             false,
             false,
             "IF_SALU"},

                                    {"SCmpLgU64",
             "SCmpLgU64",
             2,
             false,
             "Scalar Compare",
             false,
             false,
             false,
             "IF_SALU"},

                                    {"SCmpLtI32",
             "SCmpLtI32",
             2,
             false,
             "Scalar Compare",
             false,
             false,
             false,
             "IF_SALU"},

                                    {"SCmpLtU32",
             "SCmpLtU32",
             2,
             false,
             "Scalar Compare",
             false,
             false,
             false,
             "IF_SALU"},

                                    {"SBitcmp1B32",
             "SBitcmp1B32",
             2,
             false,
             "Scalar Other",
             false,
             false,
             false,
             "IF_SALU"},

                                    {"VCmpEQF32",
             "VCmpEQF32",
             2,
             true,
             "Vector Compare",
             true,
             true,
             false,
             "IF_VALU"},

                                    {"VCmpEQF64",
             "VCmpEQF64",
             2,
             true,
             "Vector Compare",
             true,
             true,
             false,
             "IF_VALU"},

                                    {"VCmpEQU32",
             "VCmpEQU32",
             2,
             true,
             "Vector Compare",
             true,
             true,
             false,
             "IF_VALU"},

                                    {"VCmpEQI32",
             "VCmpEQI32",
             2,
             true,
             "Vector Compare",
             true,
             true,
             false,
             "IF_VALU"},

                                    {"VCmpGEF16",
             "VCmpGEF16",
             2,
             true,
             "Vector Compare",
             true,
             true,
             false,
             "IF_VALU"},

                                    {"VCmpGTF16",
             "VCmpGTF16",
             2,
             true,
             "Vector Compare",
             true,
             true,
             false,
             "IF_VALU"},

                                    {"VCmpGEF32",
             "VCmpGEF32",
             2,
             true,
             "Vector Compare",
             true,
             true,
             false,
             "IF_VALU"},

                                    {"VCmpGTF32",
             "VCmpGTF32",
             2,
             true,
             "Vector Compare",
             true,
             true,
             false,
             "IF_VALU"},

                                    {"VCmpGEF64",
             "VCmpGEF64",
             2,
             true,
             "Vector Compare",
             true,
             true,
             false,
             "IF_VALU"},

                                    {"VCmpGTF64",
             "VCmpGTF64",
             2,
             true,
             "Vector Compare",
             true,
             true,
             false,
             "IF_VALU"},

                                    {"VCmpGEI32",
             "VCmpGEI32",
             2,
             true,
             "Vector Compare",
             true,
             true,
             false,
             "IF_VALU"},

                                    {"VCmpGTI32",
             "VCmpGTI32",
             2,
             true,
             "Vector Compare",
             true,
             true,
             false,
             "IF_VALU"},

                                    {"VCmpGEU32",
             "VCmpGEU32",
             2,
             true,
             "Vector Compare",
             true,
             true,
             false,
             "IF_VALU"},

                                    {"VCmpGtU32",
             "VCmpGtU32",
             2,
             true,
             "Vector Compare",
             true,
             true,
             false,
             "IF_VALU"},

                                    {"VCmpLeU32",
             "VCmpLeU32",
             2,
             true,
             "Vector Compare",
             true,
             true,
             false,
             "IF_VALU"},

                                    {"VCmpLeI32",
             "VCmpLeI32",
             2,
             true,
             "Vector Compare",
             true,
             true,
             false,
             "IF_VALU"},

                                    {"VCmpLtI32",
             "VCmpLtI32",
             2,
             true,
             "Vector Compare",
             true,
             true,
             false,
             "IF_VALU"},

                                    {"VCmpLtU32",
             "VCmpLtU32",
             2,
             true,
             "Vector Compare",
             true,
             true,
             false,
             "IF_VALU"},

                                    {"VCmpUF32",
             "VCmpUF32",
             2,
             true,
             "Vector Compare",
             true,
             true,
             false,
             "IF_VALU"},

                                    {"VCmpNeI32",
             "VCmpNeI32",
             2,
             true,
             "Vector Compare",
             true,
             true,
             false,
             "IF_VALU"},

                                    {"VCmpNeU32",
             "VCmpNeU32",
             2,
             true,
             "Vector Compare",
             true,
             true,
             false,
             "IF_VALU"},

                                    {"VCmpNeU64",
             "VCmpNeU64",
             2,
             true,
             "Vector Compare",
             true,
             true,
             false,
             "IF_VALU"},

                                    {"VCmpClassF32",
             "VCmpClassF32",
             2,
             true,
             "Vector Compare",
             true,
             true,
             false,
             "IF_VALU"},

                                    {"VCmpXClassF32",
             "VCmpXClassF32",
             2,
             true,
             "Vector Compare",
             true,
             true,
             false,
             "IF_VALU"},

                                    {"VCmpXEqU32",
             "VCmpXEqU32",
             2,
             true,
             "Vector Compare",
             true,
             true,
             false,
             "IF_VALU"},

                                    {"VCmpXGeU32",
             "VCmpXGeU32",
             2,
             true,
             "Vector Compare",
             true,
             true,
             false,
             "IF_VALU"},

                                    {"VCmpXGtU32",
             "VCmpXGtU32",
             2,
             true,
             "Vector Compare",
             true,
             true,
             false,
             "IF_VALU"},

                                    {"VCmpXLeU32",
             "VCmpXLeU32",
             2,
             true,
             "Vector Compare",
             true,
             true,
             false,
             "IF_VALU"},

                                    {"VCmpXLeI32",
             "VCmpXLeI32",
             2,
             true,
             "Vector Compare",
             true,
             true,
             false,
             "IF_VALU"},

                                    {"VCmpXLtF32",
             "VCmpXLtF32",
             2,
             true,
             "Vector Compare",
             true,
             true,
             false,
             "IF_VALU"},

                                    {"VCmpXLtI32",
             "VCmpXLtI32",
             2,
             true,
             "Vector Compare",
             true,
             true,
             false,
             "IF_VALU"},

                                    {"VCmpXLtU32",
             "VCmpXLtU32",
             2,
             true,
             "Vector Compare",
             true,
             true,
             false,
             "IF_VALU"},

                                    {"VCmpXLtU64",
             "VCmpXLtU64",
             2,
             true,
             "Vector Compare",
             true,
             true,
             false,
             "IF_VALU"},

                                    {"VCmpXNeU16",
             "VCmpXNeU16",
             2,
             true,
             "Vector Compare",
             true,
             true,
             false,
             "IF_VALU"},

                                    {"VCmpXNeU32",
             "VCmpXNeU32",
             2,
             true,
             "Vector Compare",
             true,
             true,
             false,
             "IF_VALU"},

                                    {"VCvtF16toF32",
             "VCvtF16toF32",
             1,
             true,
             "Vector Conversion",
             true,
             true,
             false,
             "IF_VALU"},

                                    {"VCvtF32toF16",
             "VCvtF32toF16",
             1,
             true,
             "Vector Conversion",
             true,
             true,
             false,
             "IF_VALU"},

                                    {"VCvtF32toU32",
             "VCvtF32toU32",
             1,
             true,
             "Vector Conversion",
             true,
             true,
             false,
             "IF_VALU"},

                                    {"VCvtU32toF32",
             "VCvtU32toF32",
             1,
             true,
             "Vector Conversion",
             true,
             true,
             false,
             "IF_VALU"},

                                    {"VCvtI32toF32",
             "VCvtI32toF32",
             1,
             true,
             "Vector Conversion",
             true,
             true,
             false,
             "IF_VALU"},

                                    {"VCvtF32toI32",
             "VCvtF32toI32",
             1,
             true,
             "Vector Conversion",
             true,
             true,
             false,
             "IF_VALU"},

                                    {"VCvtFP8toF32",
             "VCvtFP8toF32",
             1,
             true,
             "Vector Conversion",
             true,
             true,
             false,
             "IF_VALU"},

                                    {"VCvtBF8toF32",
             "VCvtBF8toF32",
             1,
             true,
             "Vector Conversion",
             true,
             true,
             false,
             "IF_VALU"},

                                    {"VCvtPkFP8toF32",
             "VCvtPkFP8toF32",
             1,
             true,
             "Vector Conversion",
             true,
             true,
             false,
             "IF_VALU"},

                                    {"VCvtPkBF8toF32",
             "VCvtPkBF8toF32",
             1,
             true,
             "Vector Conversion",
             true,
             true,
             false,
             "IF_VALU"},

                                    {"VCvtPkF32toFP8",
             "VCvtPkF32toFP8",
             2,
             true,
             "Vector Conversion",
             true,
             true,
             false,
             "IF_VALU"},

                                    {"VCvtPkF32toBF8",
             "VCvtPkF32toBF8",
             2,
             true,
             "Vector Conversion",
             true,
             true,
             false,
             "IF_VALU"},

                                    {"VCvtSRF32toFP8",
             "VCvtSRF32toFP8",
             2,
             true,
             "Vector Conversion",
             true,
             true,
             false,
             "IF_VALU"},

                                    {"VCvtSRF32toBF8",
             "VCvtSRF32toBF8",
             2,
             true,
             "Vector Conversion",
             true,
             true,
             false,
             "IF_VALU"},

                                    {"VCvtScalePkFP8toF16",
             "VCvtScalePkFP8toF16",
             2,
             true,
             "Vector Conversion",
             true,
             true,
             false,
             "IF_VALU"},

                                    {"VCvtScalePkBF8toF16",
             "VCvtScalePkBF8toF16",
             2,
             true,
             "Vector Conversion",
             true,
             true,
             false,
             "IF_VALU"},

                                    {"VCvtScaleFP8toF16",
             "VCvtScaleFP8toF16",
             2,
             true,
             "Vector Conversion",
             true,
             true,
             false,
             "IF_VALU"},

                                    {"VCvtScalePkF16toFP8",
             "VCvtScalePkF16toFP8",
             2,
             true,
             "Vector Conversion",
             true,
             true,
             false,
             "IF_VALU"},

                                    {"VCvtScalePkF16toBF8",
             "VCvtScalePkF16toBF8",
             2,
             true,
             "Vector Conversion",
             true,
             true,
             false,
             "IF_VALU"},

                                    {"VCvtScaleSRF16toFP8",
             "VCvtScaleSRF16toFP8",
             2,
             true,
             "Vector Conversion",
             true,
             true,
             false,
             "IF_VALU"},

                                    {"VCvtScaleSRF16toBF8",
             "VCvtScaleSRF16toBF8",
             2,
             true,
             "Vector Conversion",
             true,
             true,
             false,
             "IF_VALU"},

                                    {"VCvtPkF32toBF16",
             "VCvtPkF32toBF16",
             2,
             true,
             "Vector Conversion",
             true,
             true,
             false,
             "IF_VALU"},

                                    {"DSBPermuteB32",
             "DSBPermuteB32",
             1,
             true,
             "Memory Shift",
             false,
             false,
             true,
             "IF_DSRead"},

            // DS (Local Data Share) Load instructions
                                    {"DSLoadU8",
             "DSLoadU8",
             1,
             true,
             "Memory LDS",
             false,
             false,
             false,
             "IF_DSRead"},
                                    {"DSLoadI8",
             "DSLoadI8",
             1,
             true,
             "Memory LDS",
             false,
             false,
             false,
             "IF_DSRead"},
                                    {"DSLoadU16",
             "DSLoadU16",
             1,
             true,
             "Memory LDS",
             false,
             false,
             false,
             "IF_DSRead"},
                                    {"DSLoadI16",
             "DSLoadI16",
             1,
             true,
             "Memory LDS",
             false,
             false,
             false,
             "IF_DSRead"},
                                    {"DSLoadB32",
             "DSLoadB32",
             1,
             true,
             "Memory LDS",
             false,
             false,
             false,
             "IF_DSRead"},
                                    {"DSLoadB64",
             "DSLoadB64",
             1,
             true,
             "Memory LDS",
             false,
             false,
             false,
             "IF_DSRead"},
                                    {"DSLoadB96",
             "DSLoadB96",
             1,
             true,
             "Memory LDS",
             false,
             false,
             false,
             "IF_DSRead"},
                                    {"DSLoadB128",
             "DSLoadB128",
             1,
             true,
             "Memory LDS",
             false,
             false,
             false,
             "IF_DSRead"},
                                    {"DSLoad2B32",
             "DSLoad2B32",
             2,
             true,
             "Memory LDS",
             false,
             false,
             false,
             "IF_DSRead"},
                                    {"DSLoad2B64",
             "DSLoad2B64",
             2,
             true,
             "Memory LDS",
             false,
             false,
             false,
             "IF_DSRead"},

            // DS (Local Data Share) Store instructions
                                    {"DSStoreB8",
             "DSStoreB8",
             2,
             false,
             "Memory LDS",
             false,
             false,
             false,
             "IF_DSStore"},
                                    {"DSStoreB16",
             "DSStoreB16",
             2,
             false,
             "Memory LDS",
             false,
             false,
             false,
             "IF_DSStore"},
                                    {"DSStoreB32",
             "DSStoreB32",
             2,
             false,
             "Memory LDS",
             false,
             false,
             false,
             "IF_DSStore"},
                                    {"DSStoreB64",
             "DSStoreB64",
             2,
             false,
             "Memory LDS",
             false,
             false,
             false,
             "IF_DSStore"},
                                    {"DSStoreB96",
             "DSStoreB96",
             2,
             false,
             "Memory LDS",
             false,
             false,
             false,
             "IF_DSStore"},
                                    {"DSStoreB128",
             "DSStoreB128",
             2,
             false,
             "Memory LDS",
             false,
             false,
             false,
             "IF_DSStore"},
                                    {"DSStore2B32",
             "DSStore2B32",
             3,
             false,
             "Memory LDS",
             false,
             false,
             false,
             "IF_DSStore"},
                                    {"DSStore2B64",
             "DSStore2B64",
             3,
             false,
             "Memory LDS",
             false,
             false,
             false,
             "IF_DSStore"},

                                    {"BufferLoadU8",
             "BufferLoadU8",
             1,
             true,
             "Memory Memory",
             false,
             false,
             false,
             "IF_MUBUFLoad"},

                                    {"BufferLoadI8",
             "BufferLoadI8",
             1,
             true,
             "Memory Memory",
             false,
             false,
             false,
             "IF_MUBUFLoad"},

                                    {"BufferLoadU16",
             "BufferLoadU16",
             1,
             true,
             "Memory Memory",
             false,
             false,
             false,
             "IF_MUBUFLoad"},

                                    {"BufferLoadI16",
             "BufferLoadI16",
             1,
             true,
             "Memory Memory",
             false,
             false,
             false,
             "IF_MUBUFLoad"},

                                    {"BufferLoadB32",
             "BufferLoadB32",
             1,
             true,
             "Memory Memory",
             false,
             false,
             false,
             "IF_MUBUFLoad"},

                                    {"BufferLoadB64",
             "BufferLoadB64",
             1,
             true,
             "Memory Memory",
             false,
             false,
             false,
             "IF_MUBUFLoad"},

                                    {"BufferLoadB96",
             "BufferLoadB96",
             1,
             true,
             "Memory Memory",
             false,
             false,
             false,
             "IF_MUBUFLoad"},

                                    {"BufferLoadB128",
             "BufferLoadB128",
             1,
             true,
             "Memory Memory",
             false,
             false,
             false,
             "IF_MUBUFLoad"},

                                    {"BufferLoadD16U8",
             "BufferLoadD16U8",
             1,
             true,
             "Memory Memory",
             false,
             false,
             false,
             "IF_MUBUFLoad"},

                                    {"BufferLoadD16HIU8",
             "BufferLoadD16HIU8",
             1,
             true,
             "Memory Memory",
             false,
             false,
             false,
             "IF_MUBUFLoad"},

                                    {"BufferLoadD16I8",
             "BufferLoadD16I8",
             1,
             true,
             "Memory Memory",
             false,
             false,
             false,
             "IF_MUBUFLoad"},

                                    {"BufferLoadD16HII8",
             "BufferLoadD16HII8",
             1,
             true,
             "Memory Memory",
             false,
             false,
             false,
             "IF_MUBUFLoad"},

                                    {"BufferLoadD16B16",
             "BufferLoadD16B16",
             1,
             true,
             "Memory Memory",
             false,
             false,
             false,
             "IF_MUBUFLoad"},

                                    {"BufferLoadD16HIB16",
             "BufferLoadD16HIB16",
             1,
             true,
             "Memory Memory",
             false,
             false,
             false,
             "IF_MUBUFLoad"},

                                    {"BufferStoreB8",
             "BufferStoreB8",
             2,
             true,
             "Memory Memory",
             false,
             false,
             false,
             "IF_MUBUFStore"},

                                    {"BufferStoreD16HIU8",
             "BufferStoreD16HIU8",
             2,
             true,
             "Memory Memory",
             false,
             false,
             false,
             "IF_MUBUFStore"},

                                    {"BufferStoreB16",
             "BufferStoreB16",
             2,
             true,
             "Memory Memory",
             false,
             false,
             false,
             "IF_MUBUFStore"},

                                    {"BufferStoreD16HIB16",
             "BufferStoreD16HIB16",
             2,
             true,
             "Memory Memory",
             false,
             false,
             false,
             "IF_MUBUFStore"},

                                    {"BufferStoreB32",
             "BufferStoreB32",
             2,
             true,
             "Memory Memory",
             false,
             false,
             false,
             "IF_MUBUFStore"},

                                    {"BufferStoreB64",
             "BufferStoreB64",
             2,
             true,
             "Memory Memory",
             false,
             false,
             false,
             "IF_MUBUFStore"},

                                    {"BufferStoreB96",
             "BufferStoreB96",
             2,
             true,
             "Memory Memory",
             false,
             false,
             false,
             "IF_MUBUFStore"},

                                    {"BufferStoreB128",
             "BufferStoreB128",
             2,
             true,
             "Memory Memory",
             false,
             false,
             false,
             "IF_MUBUFStore"},

                                    {"BufferAtomicAddF32",
             "BufferAtomicAddF32",
             1,
             true,
             "Memory Arithmetic",
             false,
             false,
             false,
             "IF_MUBUFAtomic"},

                                    {"BufferAtomicCmpswapB32",
             "BufferAtomicCmpswapB32",
             2,
             true,
             "Memory Compare",
             false,
             false,
             false,
             "IF_MUBUFAtomic"},

                                    {"BufferAtomicCmpswapB64",
             "BufferAtomicCmpswapB64",
             2,
             true,
             "Memory Compare",
             false,
             false,
             false,
             "IF_MUBUFAtomic"},

                                    {"FlatLoadU8",
             "FlatLoadU8",
             1,
             true,
             "Memory Memory",
             false,
             false,
             false,
             "IF_FLATLoad"},

                                    {"FlatLoadI8",
             "FlatLoadI8",
             1,
             true,
             "Memory Memory",
             false,
             false,
             false,
             "IF_FLATLoad"},

                                    {"FlatLoadU16",
             "FlatLoadU16",
             1,
             true,
             "Memory Memory",
             false,
             false,
             false,
             "IF_FLATLoad"},

                                    {"FlatLoadI16",
             "FlatLoadI16",
             1,
             true,
             "Memory Memory",
             false,
             false,
             false,
             "IF_FLATLoad"},

                                    {"FlatLoadD16U8",
             "FlatLoadD16U8",
             1,
             true,
             "Memory Memory",
             false,
             false,
             false,
             "IF_FLATLoad"},

                                    {"FlatLoadD16HIU8",
             "FlatLoadD16HIU8",
             1,
             true,
             "Memory Memory",
             false,
             false,
             false,
             "IF_FLATLoad"},

                                    {"FlatLoadD16I8",
             "FlatLoadD16I8",
             1,
             true,
             "Memory Memory",
             false,
             false,
             false,
             "IF_FLATLoad"},

                                    {"FlatLoadD16HII8",
             "FlatLoadD16HII8",
             1,
             true,
             "Memory Memory",
             false,
             false,
             false,
             "IF_FLATLoad"},

                                    {"FlatLoadD16B16",
             "FlatLoadD16B16",
             1,
             true,
             "Memory Memory",
             false,
             false,
             false,
             "IF_FLATLoad"},

                                    {"FlatLoadD16HIB16",
             "FlatLoadD16HIB16",
             1,
             true,
             "Memory Memory",
             false,
             false,
             false,
             "IF_FLATLoad"},

                                    {"FlatLoadB32",
             "FlatLoadB32",
             1,
             true,
             "Memory Memory",
             false,
             false,
             false,
             "IF_FLATLoad"},

                                    {"FlatLoadB64",
             "FlatLoadB64",
             1,
             true,
             "Memory Memory",
             false,
             false,
             false,
             "IF_FLATLoad"},

                                    {"FlatLoadB96",
             "FlatLoadB96",
             1,
             true,
             "Memory Memory",
             false,
             false,
             false,
             "IF_FLATLoad"},

                                    {"FlatLoadB128",
             "FlatLoadB128",
             1,
             true,
             "Memory Memory",
             false,
             false,
             false,
             "IF_FLATLoad"},

                                    {"FlatStoreB8",
             "FlatStoreB8",
             2,
             true,
             "Memory Memory",
             false,
             false,
             false,
             "IF_FLATStore"},

                                    {"FlatStoreD16HIB8",
             "FlatStoreD16HIB8",
             2,
             true,
             "Memory Memory",
             false,
             false,
             false,
             "IF_FLATStore"},

                                    {"FlatStoreB16",
             "FlatStoreB16",
             2,
             true,
             "Memory Memory",
             false,
             false,
             false,
             "IF_FLATStore"},

                                    {"FlatStoreD16HIB16",
             "FlatStoreD16HIB16",
             2,
             true,
             "Memory Memory",
             false,
             false,
             false,
             "IF_FLATStore"},

                                    {"FlatStoreB32",
             "FlatStoreB32",
             2,
             true,
             "Memory Memory",
             false,
             false,
             false,
             "IF_FLATStore"},

                                    {"FlatStoreB64",
             "FlatStoreB64",
             2,
             true,
             "Memory Memory",
             false,
             false,
             false,
             "IF_FLATStore"},

                                    {"FlatStoreB96",
             "FlatStoreB96",
             2,
             true,
             "Memory Memory",
             false,
             false,
             false,
             "IF_FLATStore"},

                                    {"FlatStoreB128",
             "FlatStoreB128",
             2,
             true,
             "Memory Memory",
             false,
             false,
             false,
             "IF_FLATStore"},

                                    {"FlatAtomicCmpswapB32",
             "FlatAtomicCmpswapB32",
             2,
             true,
             "Memory Compare",
             false,
             false,
             false,
             "IF_FLATAtomic"},

                                    {"SAbsI32",
             "SAbsI32",
             1,
             true,
             "Scalar Arithmetic",
             false,
             false,
             false,
             "IF_SALU"},

                                    {"SBarrier",
             "SBarrier",
             0,
             false,
             "Scalar Control",
             false,
             false,
             false,
             "IF_Barrier"},

                                    {"SMaxI32",
             "SMaxI32",
             2,
             true,
             "Scalar MinMax",
             false,
             false,
             false,
             "IF_Commutative|IF_SALU"},

                                    {"SMaxU32",
             "SMaxU32",
             2,
             true,
             "Scalar MinMax",
             false,
             false,
             false,
             "IF_Commutative|IF_SALU"},

                                    {"SMinI32",
             "SMinI32",
             2,
             true,
             "Scalar MinMax",
             false,
             false,
             false,
             "IF_Commutative|IF_SALU"},

                                    {"SMinU32",
             "SMinU32",
             2,
             true,
             "Scalar MinMax",
             false,
             false,
             false,
             "IF_Commutative|IF_SALU"},

                                    {"SAddI32",
             "SAddI32",
             2,
             true,
             "Scalar Arithmetic",
             false,
             false,
             false,
             "IF_Commutative|IF_SALU"},

                                    {"SAddU32",
             "SAddU32",
             2,
             true,
             "Scalar Arithmetic",
             false,
             false,
             false,
             "IF_Commutative|IF_SALU"},

                                    {"SAddCU32",
             "SAddCU32",
             2,
             true,
             "Scalar Arithmetic",
             false,
             false,
             false,
             "IF_SALU"},

                                    {"SMulI32",
             "SMulI32",
             2,
             true,
             "Scalar Arithmetic",
             false,
             false,
             false,
             "IF_Commutative|IF_SALU"},

                                    {"SMulHII32",
             "SMulHII32",
             2,
             true,
             "Scalar Arithmetic",
             false,
             false,
             false,
             "IF_SALU"},

                                    {"SMulHIU32",
             "SMulHIU32",
             2,
             true,
             "Scalar Arithmetic",
             false,
             false,
             false,
             "IF_SALU"},

                                    {"SMulLOU32",
             "SMulLOU32",
             2,
             true,
             "Scalar Arithmetic",
             false,
             false,
             false,
             "IF_SALU"},

                                    {"SSubI32",
             "SSubI32",
             2,
             true,
             "Scalar Arithmetic",
             false,
             false,
             false,
             "IF_SALU"},

                                    {"SSubU32",
             "SSubU32",
             2,
             true,
             "Scalar Arithmetic",
             false,
             false,
             false,
             "IF_SALU"},

                                    {"SSubBU32",
             "SSubBU32",
             2,
             true,
             "Scalar Arithmetic",
             false,
             false,
             false,
             "IF_SALU"},

                                    {"SSubU64",
             "SSubU64",
             2,
             true,
             "Scalar Arithmetic",
             false,
             false,
             false,
             "IF_SALU"},

                                    {"SAndB32",
             "SAndB32",
             2,
             true,
             "Scalar Bitwise",
             false,
             false,
             false,
             "IF_Commutative|IF_SALU"},

                                    {"SAndB64",
             "SAndB64",
             2,
             true,
             "Scalar Bitwise",
             false,
             false,
             false,
             "IF_Commutative|IF_SALU"},

                                    {"SAndN2B32",
             "SAndN2B32",
             2,
             true,
             "Scalar Bitwise",
             false,
             false,
             false,
             "IF_SALU"},

                                    {"SOrB32",
             "SOrB32",
             2,
             true,
             "Scalar Bitwise",
             false,
             false,
             false,
             "IF_Commutative|IF_SALU"},

                                    {"SOrB64",
             "SOrB64",
             2,
             true,
             "Scalar Bitwise",
             false,
             false,
             false,
             "IF_Commutative|IF_SALU"},

                                    {"SXorB32",
             "SXorB32",
             2,
             true,
             "Scalar Bitwise",
             false,
             false,
             false,
             "IF_Commutative|IF_SALU"},

                                    {"SLShiftLeftB32",
             "SLShiftLeftB32",
             2,
             true,
             "Scalar Shift",
             false,
             false,
             false,
             "IF_SALU"},

                                    {"SLShiftRightB32",
             "SLShiftRightB32",
             2,
             true,
             "Scalar Shift",
             false,
             false,
             false,
             "IF_SALU"},

                                    {"SLShiftLeftB64",
             "SLShiftLeftB64",
             2,
             true,
             "Scalar Shift",
             false,
             false,
             false,
             "IF_SALU"},

                                    {"SLShiftRightB64",
             "SLShiftRightB64",
             2,
             true,
             "Scalar Shift",
             false,
             false,
             false,
             "IF_SALU"},

                                    {"SAShiftRightI32",
             "SAShiftRightI32",
             2,
             true,
             "Scalar Shift",
             false,
             false,
             false,
             "IF_SALU"},

                                    {"SLShiftLeft1AddU32",
             "SLShiftLeft1AddU32",
             2,
             true,
             "Scalar Arithmetic",
             false,
             false,
             false,
             "IF_SALU"},

                                    {"SLShiftLeft2AddU32",
             "SLShiftLeft2AddU32",
             2,
             true,
             "Scalar Arithmetic",
             false,
             false,
             false,
             "IF_SALU"},

                                    {"SLShiftLeft3AddU32",
             "SLShiftLeft3AddU32",
             2,
             true,
             "Scalar Arithmetic",
             false,
             false,
             false,
             "IF_SALU"},

                                    {"SLShiftLeft4AddU32",
             "SLShiftLeft4AddU32",
             2,
             true,
             "Scalar Arithmetic",
             false,
             false,
             false,
             "IF_SALU"},

                                    {"SMovB32",
             "SMovB32",
             1,
             true,
             "Scalar Move",
             false,
             false,
             false,
             "IF_SALU"},

                                    {"SMovB64",
             "SMovB64",
             1,
             true,
             "Scalar Move",
             false,
             false,
             false,
             "IF_SALU"},

                                    {"SCMovB32",
             "SCMovB32",
             1,
             true,
             "Scalar Move",
             false,
             false,
             false,
             "IF_SALU"},

                                    {"SCMovB64",
             "SCMovB64",
             1,
             true,
             "Scalar Move",
             false,
             false,
             false,
             "IF_SALU"},

                                    {"SCSelectB32",
             "SCSelectB32",
             2,
             true,
             "Scalar Other",
             false,
             false,
             false,
             "IF_SALU"},

                                    {"SGetPCB64",
             "SGetPCB64",
             0,
             true,
             "Scalar Other",
             false,
             false,
             false,
             "IF_SALU"},

                                    {"SSetMask",
             "SSetMask",
             1,
             true,
             "Scalar Other",
             false,
             false,
             false,
             "IF_HasSideEffect"},

                                    {"SFf1B32",
             "SFf1B32",
             1,
             true,
             "Scalar Other",
             false,
             false,
             false,
             "IF_SALU"},

                                    {"SBfmB32",
             "SBfmB32",
             2,
             true,
             "Scalar Other",
             false,
             false,
             false,
             "IF_SALU"},

                                    {"SMovkI32",
             "SMovkI32",
             1,
             true,
             "Scalar Move",
             false,
             false,
             false,
             "IF_SALU"},

                                    {"SSExtI16toI32",
             "SSExtI16toI32",
             1,
             true,
             "Scalar Other",
             false,
             false,
             false,
             "IF_SALU"},

                                    {"SAndSaveExecB32",
             "SAndSaveExecB32",
             1,
             true,
             "Scalar Bitwise",
             false,
             false,
             false,
             "IF_SALU"},

                                    {"SAndSaveExecB64",
             "SAndSaveExecB64",
             1,
             true,
             "Scalar Bitwise",
             false,
             false,
             false,
             "IF_Branch"},

                                    {"SOrSaveExecB32",
             "SOrSaveExecB32",
             1,
             true,
             "Scalar Bitwise",
             false,
             false,
             false,
             "IF_SALU"},

                                    {"SOrSaveExecB64",
             "SOrSaveExecB64",
             1,
             true,
             "Scalar Bitwise",
             false,
             false,
             false,
             "IF_SALU"},

                                    {"SGetRegB32",
             "SGetRegB32",
             1,
             true,
             "Scalar Control",
             false,
             false,
             false,
             "IF_HasSideEffect"},

                                    {"SSetRegB32",
             "SSetRegB32",
             1,
             true,
             "Scalar Control",
             false,
             false,
             false,
             "IF_HasSideEffect"},

                                    {"SSetRegIMM32B32",
             "SSetRegIMM32B32",
             1,
             true,
             "Scalar Control",
             false,
             false,
             false,
             "IF_HasSideEffect"},

            // ========================================================================
            // Composite Instructions
            // ========================================================================

                                    {"VAddPKF32",
             "VAddPKF32",
             2,
             true,
             "Vector Arithmetic",
             true,
             true,
             false,
             "IF_Commutative|IF_VALU"},

                                    {"VMulPKF32",
             "VMulPKF32",
             2,
             true,
             "Vector Arithmetic",
             true,
             true,
             false,
             "IF_Commutative|IF_VALU"},

                                    {"VMovB64",
             "VMovB64",
             1,
             true,
             "Vector Move",
             false,
             false,
             false,
             "IF_VALU"},

                                    {"VLShiftLeftOrB32",
             "VLShiftLeftOrB32",
             3,
             true,
             "Vector Arithmetic",
             true,
             true,
             false,
             "IF_VALU"},

                                    {"TensorLoadToLds",
             "TensorLoadToLds: Loads tensor data to LDS",
             4,
             false,
             "Tensor Memory",
             false,
             false,
             false,
             "IF_TENSORLoadToLds",
             2},
