/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
|*                                                                            *|
|* Compress instruction Source Fragment                                       *|
|*                                                                            *|
|* Automatically generated file, do not edit!                                 *|
|*                                                                            *|
\*===----------------------------------------------------------------------===*/


#ifdef GEN_COMPRESS_INSTR
#undef GEN_COMPRESS_INSTR

static bool RISCVValidateMCOperand(const MCOperand &MCOp,
                  const MCSubtargetInfo &STI,
                  unsigned PredicateIndex) {
  switch (PredicateIndex) {
  default:
    llvm_unreachable("Unknown MCOperandPredicate kind");
    break;
  case 1: {
  // uimm10_lsb00nonzero

    int64_t Imm;
    if (!MCOp.evaluateAsConstantImm(Imm))
      return false;
    return isShiftedUInt<8, 2>(Imm) && (Imm != 0);

  }
  case 2: {
  // simm6nonzero

    int64_t Imm;
    if (MCOp.evaluateAsConstantImm(Imm))
      return (Imm != 0) && isInt<6>(Imm);
    return MCOp.isBareSymbolRef();

  }
  case 3: {
  // simm6

    int64_t Imm;
    if (MCOp.evaluateAsConstantImm(Imm))
      return isInt<6>(Imm);
    return MCOp.isBareSymbolRef();

  }
  case 4: {
  // simm10_lsb0000nonzero

    int64_t Imm;
    if (!MCOp.evaluateAsConstantImm(Imm))
      return false;
    return isShiftedInt<6, 4>(Imm) && (Imm != 0);

  }
  case 5: {
  // simm9_lsb0

    int64_t Imm;
    if (MCOp.evaluateAsConstantImm(Imm))
      return isShiftedInt<8, 1>(Imm);
    return MCOp.isBareSymbolRef();


  }
  case 6: {
  // uimm8_lsb000

    int64_t Imm;
    if (!MCOp.evaluateAsConstantImm(Imm))
      return false;
    return isShiftedUInt<5, 3>(Imm);

  }
  case 7: {
  // uimm9_lsb000

    int64_t Imm;
    if (!MCOp.evaluateAsConstantImm(Imm))
      return false;
    return isShiftedUInt<6, 3>(Imm);

  }
  case 8: {
  // uimm7_lsb00

    int64_t Imm;
    if (!MCOp.evaluateAsConstantImm(Imm))
      return false;
    return isShiftedUInt<5, 2>(Imm);

  }
  case 9: {
  // uimm8_lsb00

    int64_t Imm;
    if (!MCOp.evaluateAsConstantImm(Imm))
      return false;
    return isShiftedUInt<6, 2>(Imm);

  }
  case 10: {
  // simm12_lsb0

    int64_t Imm;
    if (MCOp.evaluateAsConstantImm(Imm))
      return isShiftedInt<11, 1>(Imm);
    return MCOp.isBareSymbolRef();

  }
  case 11: {
  // c_lui_imm

    int64_t Imm;
    if (MCOp.evaluateAsConstantImm(Imm))
      return (Imm != 0) && (isUInt<5>(Imm) ||
             (Imm >= 0xfffe0 && Imm <= 0xfffff));
    return MCOp.isBareSymbolRef();

  }
  case 12: {
  // uimmlog2xlennonzero

    int64_t Imm;
    if (!MCOp.evaluateAsConstantImm(Imm))
      return false;
    if (STI.getTargetTriple().isArch64Bit())
      return  isUInt<6>(Imm) && (Imm != 0);
    return isUInt<5>(Imm) && (Imm != 0);

  }
  }
}

static bool compressInst(MCInst& OutInst,
                         const MCInst &MI,
                         const MCSubtargetInfo &STI,
                         MCContext &Context) {
  const MCRegisterInfo &MRI = *Context.getRegisterInfo();
  switch (MI.getOpcode()) {
    default: return false;
    case RISCV::ADD: {
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MI.getOperand(1).getReg() == RISCV::X0) &&
      (MRI.getRegClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(2).getReg()))) {
      // c.mv	$rs1, $rs2
      OutInst.setOpcode(RISCV::C_MV);
      // Operand: rs1
      OutInst.addOperand(MI.getOperand(0));
      // Operand: rs2
      OutInst.addOperand(MI.getOperand(2));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MI.getOperand(2).getReg() == RISCV::X0) &&
      (MRI.getRegClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(1).getReg()))) {
      // c.mv	$rs1, $rs2
      OutInst.setOpcode(RISCV::C_MV);
      // Operand: rs1
      OutInst.addOperand(MI.getOperand(0));
      // Operand: rs2
      OutInst.addOperand(MI.getOperand(1));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MI.getOperand(1).getReg() ==  MI.getOperand(0).getReg()) &&
      (MRI.getRegClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(1).getReg())) &&
      (MRI.getRegClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(2).getReg()))) {
      // c.add	$rs1, $rs2
      OutInst.setOpcode(RISCV::C_ADD);
      // Operand: rs1_wb
      OutInst.addOperand(MI.getOperand(1));
      // Operand: rs1
      OutInst.addOperand(MI.getOperand(1));
      // Operand: rs2
      OutInst.addOperand(MI.getOperand(2));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MI.getOperand(2).getReg() ==  MI.getOperand(0).getReg()) &&
      (MRI.getRegClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(2).getReg())) &&
      (MRI.getRegClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(1).getReg()))) {
      // c.add	$rs1, $rs2
      OutInst.setOpcode(RISCV::C_ADD);
      // Operand: rs1_wb
      OutInst.addOperand(MI.getOperand(2));
      // Operand: rs1
      OutInst.addOperand(MI.getOperand(2));
      // Operand: rs2
      OutInst.addOperand(MI.getOperand(1));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
      break;
    } // case ADD
    case RISCV::ADDI: {
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MRI.getRegClass(RISCV::GPRCRegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::SPRegClassID).contains(MI.getOperand(1).getReg())) &&
      RISCVValidateMCOperand(MI.getOperand(2), STI, 1)) {
      // c.addi4spn	$rd, $rs1, $imm
      OutInst.setOpcode(RISCV::C_ADDI4SPN);
      // Operand: rd
      OutInst.addOperand(MI.getOperand(0));
      // Operand: rs1
      OutInst.addOperand(MI.getOperand(1));
      // Operand: imm
      OutInst.addOperand(MI.getOperand(2));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MI.getOperand(0).getReg() == RISCV::X0) &&
      (MI.getOperand(1).getReg() == RISCV::X0) &&
      (MI.getOperand(2).isImm()) &&
      (MI.getOperand(2).getImm() == 0)) {
      // c.nop
      OutInst.setOpcode(RISCV::C_NOP);
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MI.getOperand(1).getReg() ==  MI.getOperand(0).getReg()) &&
      (MRI.getRegClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(1).getReg())) &&
      RISCVValidateMCOperand(MI.getOperand(2), STI, 2)) {
      // c.addi	$rd, $imm
      OutInst.setOpcode(RISCV::C_ADDI);
      // Operand: rd_wb
      OutInst.addOperand(MI.getOperand(1));
      // Operand: rd
      OutInst.addOperand(MI.getOperand(1));
      // Operand: imm
      OutInst.addOperand(MI.getOperand(2));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MI.getOperand(1).getReg() == RISCV::X0) &&
      (MRI.getRegClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(0).getReg())) &&
      RISCVValidateMCOperand(MI.getOperand(2), STI, 3)) {
      // c.li	$rd, $imm
      OutInst.setOpcode(RISCV::C_LI);
      // Operand: rd
      OutInst.addOperand(MI.getOperand(0));
      // Operand: imm
      OutInst.addOperand(MI.getOperand(2));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MI.getOperand(0).getReg() == RISCV::X2) &&
      (MI.getOperand(1).getReg() == RISCV::X2) &&
      RISCVValidateMCOperand(MI.getOperand(2), STI, 4)) {
      // c.addi16sp	$rd, $imm
      OutInst.setOpcode(RISCV::C_ADDI16SP);
      // Operand: rd_wb
      OutInst.addOperand(MCOperand::createReg(RISCV::X2));
      // Operand: rd
      OutInst.addOperand(MCOperand::createReg(RISCV::X2));
      // Operand: imm
      OutInst.addOperand(MI.getOperand(2));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MI.getOperand(2).isImm()) &&
      (MI.getOperand(2).getImm() == 0) &&
      (MRI.getRegClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(1).getReg()))) {
      // c.mv	$rs1, $rs2
      OutInst.setOpcode(RISCV::C_MV);
      // Operand: rs1
      OutInst.addOperand(MI.getOperand(0));
      // Operand: rs2
      OutInst.addOperand(MI.getOperand(1));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
      break;
    } // case ADDI
    case RISCV::ADDIW: {
    if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
      STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MI.getOperand(1).getReg() ==  MI.getOperand(0).getReg()) &&
      (MRI.getRegClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(1).getReg())) &&
      RISCVValidateMCOperand(MI.getOperand(2), STI, 3)) {
      // c.addiw	$rd, $imm
      OutInst.setOpcode(RISCV::C_ADDIW);
      // Operand: rd_wb
      OutInst.addOperand(MI.getOperand(1));
      // Operand: rd
      OutInst.addOperand(MI.getOperand(1));
      // Operand: imm
      OutInst.addOperand(MI.getOperand(2));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
    if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
      STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MI.getOperand(1).getReg() == RISCV::X0) &&
      (MRI.getRegClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(0).getReg())) &&
      RISCVValidateMCOperand(MI.getOperand(2), STI, 3)) {
      // c.li	$rd, $imm
      OutInst.setOpcode(RISCV::C_LI);
      // Operand: rd
      OutInst.addOperand(MI.getOperand(0));
      // Operand: imm
      OutInst.addOperand(MI.getOperand(2));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
      break;
    } // case ADDIW
    case RISCV::ADDW: {
    if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
      STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MI.getOperand(1).getReg() ==  MI.getOperand(0).getReg()) &&
      (MRI.getRegClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg())) &&
      (MRI.getRegClass(RISCV::GPRCRegClassID).contains(MI.getOperand(2).getReg()))) {
      // c.addw	$rd, $rs2
      OutInst.setOpcode(RISCV::C_ADDW);
      // Operand: rd_wb
      OutInst.addOperand(MI.getOperand(1));
      // Operand: rd
      OutInst.addOperand(MI.getOperand(1));
      // Operand: rs2
      OutInst.addOperand(MI.getOperand(2));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
    if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
      STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MI.getOperand(2).getReg() ==  MI.getOperand(0).getReg()) &&
      (MRI.getRegClass(RISCV::GPRCRegClassID).contains(MI.getOperand(2).getReg())) &&
      (MRI.getRegClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg()))) {
      // c.addw	$rd, $rs2
      OutInst.setOpcode(RISCV::C_ADDW);
      // Operand: rd_wb
      OutInst.addOperand(MI.getOperand(2));
      // Operand: rd
      OutInst.addOperand(MI.getOperand(2));
      // Operand: rs2
      OutInst.addOperand(MI.getOperand(1));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
      break;
    } // case ADDW
    case RISCV::AND: {
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MI.getOperand(1).getReg() ==  MI.getOperand(0).getReg()) &&
      (MRI.getRegClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg())) &&
      (MRI.getRegClass(RISCV::GPRCRegClassID).contains(MI.getOperand(2).getReg()))) {
      // c.and	$rd, $rs2
      OutInst.setOpcode(RISCV::C_AND);
      // Operand: rd_wb
      OutInst.addOperand(MI.getOperand(1));
      // Operand: rd
      OutInst.addOperand(MI.getOperand(1));
      // Operand: rs2
      OutInst.addOperand(MI.getOperand(2));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MI.getOperand(2).getReg() ==  MI.getOperand(0).getReg()) &&
      (MRI.getRegClass(RISCV::GPRCRegClassID).contains(MI.getOperand(2).getReg())) &&
      (MRI.getRegClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg()))) {
      // c.and	$rd, $rs2
      OutInst.setOpcode(RISCV::C_AND);
      // Operand: rd_wb
      OutInst.addOperand(MI.getOperand(2));
      // Operand: rd
      OutInst.addOperand(MI.getOperand(2));
      // Operand: rs2
      OutInst.addOperand(MI.getOperand(1));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
      break;
    } // case AND
    case RISCV::ANDI: {
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MI.getOperand(1).getReg() ==  MI.getOperand(0).getReg()) &&
      (MRI.getRegClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg())) &&
      RISCVValidateMCOperand(MI.getOperand(2), STI, 3)) {
      // c.andi	$rs1, $imm
      OutInst.setOpcode(RISCV::C_ANDI);
      // Operand: rs1_wb
      OutInst.addOperand(MI.getOperand(1));
      // Operand: rs1
      OutInst.addOperand(MI.getOperand(1));
      // Operand: imm
      OutInst.addOperand(MI.getOperand(2));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
      break;
    } // case ANDI
    case RISCV::BEQ: {
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MI.getOperand(1).getReg() == RISCV::X0) &&
      (MRI.getRegClass(RISCV::GPRCRegClassID).contains(MI.getOperand(0).getReg())) &&
      RISCVValidateMCOperand(MI.getOperand(2), STI, 5)) {
      // c.beqz	$rs1, $imm
      OutInst.setOpcode(RISCV::C_BEQZ);
      // Operand: rs1
      OutInst.addOperand(MI.getOperand(0));
      // Operand: imm
      OutInst.addOperand(MI.getOperand(2));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
      break;
    } // case BEQ
    case RISCV::BNE: {
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MI.getOperand(1).getReg() == RISCV::X0) &&
      (MRI.getRegClass(RISCV::GPRCRegClassID).contains(MI.getOperand(0).getReg())) &&
      RISCVValidateMCOperand(MI.getOperand(2), STI, 5)) {
      // c.bnez	$rs1, $imm
      OutInst.setOpcode(RISCV::C_BNEZ);
      // Operand: rs1
      OutInst.addOperand(MI.getOperand(0));
      // Operand: imm
      OutInst.addOperand(MI.getOperand(2));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
      break;
    } // case BNE
    case RISCV::EBREAK: {
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC]) {
      // c.ebreak
      OutInst.setOpcode(RISCV::C_EBREAK);
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
      break;
    } // case EBREAK
    case RISCV::FLD: {
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      STI.getFeatureBits()[RISCV::FeatureStdExtD] &&
      (MRI.getRegClass(RISCV::FPR64CRegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg())) &&
      RISCVValidateMCOperand(MI.getOperand(2), STI, 6)) {
      // c.fld	$rd, ${imm}(${rs1})
      OutInst.setOpcode(RISCV::C_FLD);
      // Operand: rd
      OutInst.addOperand(MI.getOperand(0));
      // Operand: rs1
      OutInst.addOperand(MI.getOperand(1));
      // Operand: imm
      OutInst.addOperand(MI.getOperand(2));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      STI.getFeatureBits()[RISCV::FeatureStdExtD] &&
      (MRI.getRegClass(RISCV::FPR64RegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::SPRegClassID).contains(MI.getOperand(1).getReg())) &&
      RISCVValidateMCOperand(MI.getOperand(2), STI, 7)) {
      // c.fldsp	$rd, ${imm}(${rs1})
      OutInst.setOpcode(RISCV::C_FLDSP);
      // Operand: rd
      OutInst.addOperand(MI.getOperand(0));
      // Operand: rs1
      OutInst.addOperand(MI.getOperand(1));
      // Operand: imm
      OutInst.addOperand(MI.getOperand(2));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
      break;
    } // case FLD
    case RISCV::FLW: {
    if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
      STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      STI.getFeatureBits()[RISCV::FeatureStdExtF] &&
      (MRI.getRegClass(RISCV::FPR32CRegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg())) &&
      RISCVValidateMCOperand(MI.getOperand(2), STI, 8)) {
      // c.flw	$rd, ${imm}(${rs1})
      OutInst.setOpcode(RISCV::C_FLW);
      // Operand: rd
      OutInst.addOperand(MI.getOperand(0));
      // Operand: rs1
      OutInst.addOperand(MI.getOperand(1));
      // Operand: imm
      OutInst.addOperand(MI.getOperand(2));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
    if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
      STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      STI.getFeatureBits()[RISCV::FeatureStdExtF] &&
      (MRI.getRegClass(RISCV::FPR32RegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::SPRegClassID).contains(MI.getOperand(1).getReg())) &&
      RISCVValidateMCOperand(MI.getOperand(2), STI, 9)) {
      // c.flwsp	$rd, ${imm}(${rs1})
      OutInst.setOpcode(RISCV::C_FLWSP);
      // Operand: rd
      OutInst.addOperand(MI.getOperand(0));
      // Operand: rs1
      OutInst.addOperand(MI.getOperand(1));
      // Operand: imm
      OutInst.addOperand(MI.getOperand(2));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
      break;
    } // case FLW
    case RISCV::FSD: {
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      STI.getFeatureBits()[RISCV::FeatureStdExtD] &&
      (MRI.getRegClass(RISCV::FPR64CRegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg())) &&
      RISCVValidateMCOperand(MI.getOperand(2), STI, 6)) {
      // c.fsd	$rs2, ${imm}(${rs1})
      OutInst.setOpcode(RISCV::C_FSD);
      // Operand: rs2
      OutInst.addOperand(MI.getOperand(0));
      // Operand: rs1
      OutInst.addOperand(MI.getOperand(1));
      // Operand: imm
      OutInst.addOperand(MI.getOperand(2));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      STI.getFeatureBits()[RISCV::FeatureStdExtD] &&
      (MRI.getRegClass(RISCV::FPR64RegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::SPRegClassID).contains(MI.getOperand(1).getReg())) &&
      RISCVValidateMCOperand(MI.getOperand(2), STI, 7)) {
      // c.fsdsp	$rs2, ${imm}(${rs1})
      OutInst.setOpcode(RISCV::C_FSDSP);
      // Operand: rs2
      OutInst.addOperand(MI.getOperand(0));
      // Operand: rs1
      OutInst.addOperand(MI.getOperand(1));
      // Operand: imm
      OutInst.addOperand(MI.getOperand(2));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
      break;
    } // case FSD
    case RISCV::FSW: {
    if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
      STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      STI.getFeatureBits()[RISCV::FeatureStdExtF] &&
      (MRI.getRegClass(RISCV::FPR32CRegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg())) &&
      RISCVValidateMCOperand(MI.getOperand(2), STI, 8)) {
      // c.fsw	$rs2, ${imm}(${rs1})
      OutInst.setOpcode(RISCV::C_FSW);
      // Operand: rs2
      OutInst.addOperand(MI.getOperand(0));
      // Operand: rs1
      OutInst.addOperand(MI.getOperand(1));
      // Operand: imm
      OutInst.addOperand(MI.getOperand(2));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
    if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
      STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      STI.getFeatureBits()[RISCV::FeatureStdExtF] &&
      (MRI.getRegClass(RISCV::FPR32RegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::SPRegClassID).contains(MI.getOperand(1).getReg())) &&
      RISCVValidateMCOperand(MI.getOperand(2), STI, 9)) {
      // c.fswsp	$rs2, ${imm}(${rs1})
      OutInst.setOpcode(RISCV::C_FSWSP);
      // Operand: rs2
      OutInst.addOperand(MI.getOperand(0));
      // Operand: rs1
      OutInst.addOperand(MI.getOperand(1));
      // Operand: imm
      OutInst.addOperand(MI.getOperand(2));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
      break;
    } // case FSW
    case RISCV::JAL: {
    if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
      STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MI.getOperand(0).getReg() == RISCV::X1) &&
      RISCVValidateMCOperand(MI.getOperand(1), STI, 10)) {
      // c.jal	$offset
      OutInst.setOpcode(RISCV::C_JAL);
      // Operand: offset
      OutInst.addOperand(MI.getOperand(1));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MI.getOperand(0).getReg() == RISCV::X0) &&
      RISCVValidateMCOperand(MI.getOperand(1), STI, 10)) {
      // c.j	$offset
      OutInst.setOpcode(RISCV::C_J);
      // Operand: offset
      OutInst.addOperand(MI.getOperand(1));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
      break;
    } // case JAL
    case RISCV::JALR: {
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MI.getOperand(0).getReg() == RISCV::X0) &&
      (MI.getOperand(2).isImm()) &&
      (MI.getOperand(2).getImm() == 0) &&
      (MRI.getRegClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(1).getReg()))) {
      // c.jr	$rs1
      OutInst.setOpcode(RISCV::C_JR);
      // Operand: rs1
      OutInst.addOperand(MI.getOperand(1));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MI.getOperand(0).getReg() == RISCV::X1) &&
      (MI.getOperand(2).isImm()) &&
      (MI.getOperand(2).getImm() == 0) &&
      (MRI.getRegClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(1).getReg()))) {
      // c.jalr	$rs1
      OutInst.setOpcode(RISCV::C_JALR);
      // Operand: rs1
      OutInst.addOperand(MI.getOperand(1));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
      break;
    } // case JALR
    case RISCV::LD: {
    if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
      STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MRI.getRegClass(RISCV::GPRCRegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg())) &&
      RISCVValidateMCOperand(MI.getOperand(2), STI, 6)) {
      // c.ld	$rd, ${imm}(${rs1})
      OutInst.setOpcode(RISCV::C_LD);
      // Operand: rd
      OutInst.addOperand(MI.getOperand(0));
      // Operand: rs1
      OutInst.addOperand(MI.getOperand(1));
      // Operand: imm
      OutInst.addOperand(MI.getOperand(2));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
    if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
      STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MRI.getRegClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::SPRegClassID).contains(MI.getOperand(1).getReg())) &&
      RISCVValidateMCOperand(MI.getOperand(2), STI, 7)) {
      // c.ldsp	$rd, ${imm}(${rs1})
      OutInst.setOpcode(RISCV::C_LDSP);
      // Operand: rd
      OutInst.addOperand(MI.getOperand(0));
      // Operand: rs1
      OutInst.addOperand(MI.getOperand(1));
      // Operand: imm
      OutInst.addOperand(MI.getOperand(2));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
      break;
    } // case LD
    case RISCV::LUI: {
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MRI.getRegClass(RISCV::GPRNoX0X2RegClassID).contains(MI.getOperand(0).getReg())) &&
      RISCVValidateMCOperand(MI.getOperand(1), STI, 11)) {
      // c.lui	$rd, $imm
      OutInst.setOpcode(RISCV::C_LUI);
      // Operand: rd
      OutInst.addOperand(MI.getOperand(0));
      // Operand: imm
      OutInst.addOperand(MI.getOperand(1));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
      break;
    } // case LUI
    case RISCV::LW: {
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MRI.getRegClass(RISCV::GPRCRegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg())) &&
      RISCVValidateMCOperand(MI.getOperand(2), STI, 8)) {
      // c.lw	$rd, ${imm}(${rs1})
      OutInst.setOpcode(RISCV::C_LW);
      // Operand: rd
      OutInst.addOperand(MI.getOperand(0));
      // Operand: rs1
      OutInst.addOperand(MI.getOperand(1));
      // Operand: imm
      OutInst.addOperand(MI.getOperand(2));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MRI.getRegClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::SPRegClassID).contains(MI.getOperand(1).getReg())) &&
      RISCVValidateMCOperand(MI.getOperand(2), STI, 9)) {
      // c.lwsp	$rd, ${imm}(${rs1})
      OutInst.setOpcode(RISCV::C_LWSP);
      // Operand: rd
      OutInst.addOperand(MI.getOperand(0));
      // Operand: rs1
      OutInst.addOperand(MI.getOperand(1));
      // Operand: imm
      OutInst.addOperand(MI.getOperand(2));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
      break;
    } // case LW
    case RISCV::OR: {
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MI.getOperand(1).getReg() ==  MI.getOperand(0).getReg()) &&
      (MRI.getRegClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg())) &&
      (MRI.getRegClass(RISCV::GPRCRegClassID).contains(MI.getOperand(2).getReg()))) {
      // c.or	$rd, $rs2
      OutInst.setOpcode(RISCV::C_OR);
      // Operand: rd_wb
      OutInst.addOperand(MI.getOperand(1));
      // Operand: rd
      OutInst.addOperand(MI.getOperand(1));
      // Operand: rs2
      OutInst.addOperand(MI.getOperand(2));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MI.getOperand(2).getReg() ==  MI.getOperand(0).getReg()) &&
      (MRI.getRegClass(RISCV::GPRCRegClassID).contains(MI.getOperand(2).getReg())) &&
      (MRI.getRegClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg()))) {
      // c.or	$rd, $rs2
      OutInst.setOpcode(RISCV::C_OR);
      // Operand: rd_wb
      OutInst.addOperand(MI.getOperand(2));
      // Operand: rd
      OutInst.addOperand(MI.getOperand(2));
      // Operand: rs2
      OutInst.addOperand(MI.getOperand(1));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
      break;
    } // case OR
    case RISCV::SD: {
    if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
      STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MRI.getRegClass(RISCV::GPRCRegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg())) &&
      RISCVValidateMCOperand(MI.getOperand(2), STI, 6)) {
      // c.sd	$rs2, ${imm}(${rs1})
      OutInst.setOpcode(RISCV::C_SD);
      // Operand: rs2
      OutInst.addOperand(MI.getOperand(0));
      // Operand: rs1
      OutInst.addOperand(MI.getOperand(1));
      // Operand: imm
      OutInst.addOperand(MI.getOperand(2));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
    if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
      STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::SPRegClassID).contains(MI.getOperand(1).getReg())) &&
      RISCVValidateMCOperand(MI.getOperand(2), STI, 7)) {
      // c.sdsp	$rs2, ${imm}(${rs1})
      OutInst.setOpcode(RISCV::C_SDSP);
      // Operand: rs2
      OutInst.addOperand(MI.getOperand(0));
      // Operand: rs1
      OutInst.addOperand(MI.getOperand(1));
      // Operand: imm
      OutInst.addOperand(MI.getOperand(2));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
      break;
    } // case SD
    case RISCV::SLLI: {
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MI.getOperand(1).getReg() ==  MI.getOperand(0).getReg()) &&
      (MRI.getRegClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(1).getReg())) &&
      RISCVValidateMCOperand(MI.getOperand(2), STI, 12)) {
      // c.slli	$rd, $imm
      OutInst.setOpcode(RISCV::C_SLLI);
      // Operand: rd_wb
      OutInst.addOperand(MI.getOperand(1));
      // Operand: rd
      OutInst.addOperand(MI.getOperand(1));
      // Operand: imm
      OutInst.addOperand(MI.getOperand(2));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
      break;
    } // case SLLI
    case RISCV::SRAI: {
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MI.getOperand(1).getReg() ==  MI.getOperand(0).getReg()) &&
      (MRI.getRegClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg())) &&
      RISCVValidateMCOperand(MI.getOperand(2), STI, 12)) {
      // c.srai	$rs1, $imm
      OutInst.setOpcode(RISCV::C_SRAI);
      // Operand: rs1_wb
      OutInst.addOperand(MI.getOperand(1));
      // Operand: rs1
      OutInst.addOperand(MI.getOperand(1));
      // Operand: imm
      OutInst.addOperand(MI.getOperand(2));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
      break;
    } // case SRAI
    case RISCV::SRLI: {
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MI.getOperand(1).getReg() ==  MI.getOperand(0).getReg()) &&
      (MRI.getRegClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg())) &&
      RISCVValidateMCOperand(MI.getOperand(2), STI, 12)) {
      // c.srli	$rs1, $imm
      OutInst.setOpcode(RISCV::C_SRLI);
      // Operand: rs1_wb
      OutInst.addOperand(MI.getOperand(1));
      // Operand: rs1
      OutInst.addOperand(MI.getOperand(1));
      // Operand: imm
      OutInst.addOperand(MI.getOperand(2));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
      break;
    } // case SRLI
    case RISCV::SUB: {
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MI.getOperand(1).getReg() ==  MI.getOperand(0).getReg()) &&
      (MRI.getRegClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg())) &&
      (MRI.getRegClass(RISCV::GPRCRegClassID).contains(MI.getOperand(2).getReg()))) {
      // c.sub	$rd, $rs2
      OutInst.setOpcode(RISCV::C_SUB);
      // Operand: rd_wb
      OutInst.addOperand(MI.getOperand(1));
      // Operand: rd
      OutInst.addOperand(MI.getOperand(1));
      // Operand: rs2
      OutInst.addOperand(MI.getOperand(2));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
      break;
    } // case SUB
    case RISCV::SUBW: {
    if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
      STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MI.getOperand(1).getReg() ==  MI.getOperand(0).getReg()) &&
      (MRI.getRegClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg())) &&
      (MRI.getRegClass(RISCV::GPRCRegClassID).contains(MI.getOperand(2).getReg()))) {
      // c.subw	$rd, $rs2
      OutInst.setOpcode(RISCV::C_SUBW);
      // Operand: rd_wb
      OutInst.addOperand(MI.getOperand(1));
      // Operand: rd
      OutInst.addOperand(MI.getOperand(1));
      // Operand: rs2
      OutInst.addOperand(MI.getOperand(2));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
      break;
    } // case SUBW
    case RISCV::SW: {
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MRI.getRegClass(RISCV::GPRCRegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg())) &&
      RISCVValidateMCOperand(MI.getOperand(2), STI, 8)) {
      // c.sw	$rs2, ${imm}(${rs1})
      OutInst.setOpcode(RISCV::C_SW);
      // Operand: rs2
      OutInst.addOperand(MI.getOperand(0));
      // Operand: rs1
      OutInst.addOperand(MI.getOperand(1));
      // Operand: imm
      OutInst.addOperand(MI.getOperand(2));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::SPRegClassID).contains(MI.getOperand(1).getReg())) &&
      RISCVValidateMCOperand(MI.getOperand(2), STI, 9)) {
      // c.swsp	$rs2, ${imm}(${rs1})
      OutInst.setOpcode(RISCV::C_SWSP);
      // Operand: rs2
      OutInst.addOperand(MI.getOperand(0));
      // Operand: rs1
      OutInst.addOperand(MI.getOperand(1));
      // Operand: imm
      OutInst.addOperand(MI.getOperand(2));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
      break;
    } // case SW
    case RISCV::UNIMP: {
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC]) {
      // c.unimp
      OutInst.setOpcode(RISCV::C_UNIMP);
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
      break;
    } // case UNIMP
    case RISCV::XOR: {
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MI.getOperand(1).getReg() ==  MI.getOperand(0).getReg()) &&
      (MRI.getRegClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg())) &&
      (MRI.getRegClass(RISCV::GPRCRegClassID).contains(MI.getOperand(2).getReg()))) {
      // c.xor	$rd, $rs2
      OutInst.setOpcode(RISCV::C_XOR);
      // Operand: rd_wb
      OutInst.addOperand(MI.getOperand(1));
      // Operand: rd
      OutInst.addOperand(MI.getOperand(1));
      // Operand: rs2
      OutInst.addOperand(MI.getOperand(2));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MI.getOperand(2).getReg() ==  MI.getOperand(0).getReg()) &&
      (MRI.getRegClass(RISCV::GPRCRegClassID).contains(MI.getOperand(2).getReg())) &&
      (MRI.getRegClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg()))) {
      // c.xor	$rd, $rs2
      OutInst.setOpcode(RISCV::C_XOR);
      // Operand: rd_wb
      OutInst.addOperand(MI.getOperand(2));
      // Operand: rd
      OutInst.addOperand(MI.getOperand(2));
      // Operand: rs2
      OutInst.addOperand(MI.getOperand(1));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if

    } // case XOR
  } // switch
  return false;
}

#endif //GEN_COMPRESS_INSTR

#ifdef GEN_UNCOMPRESS_INSTR
#undef GEN_UNCOMPRESS_INSTR

static bool RISCVValidateMCOperand(const MCOperand &MCOp,
                  const MCSubtargetInfo &STI,
                  unsigned PredicateIndex) {
  switch (PredicateIndex) {
  default:
    llvm_unreachable("Unknown MCOperandPredicate kind");
    break;
  case 1: {
  // simm12

    int64_t Imm;
    if (MCOp.evaluateAsConstantImm(Imm))
      return isInt<12>(Imm);
    return MCOp.isBareSymbolRef();

  }
  case 2: {
  // simm13_lsb0

    int64_t Imm;
    if (MCOp.evaluateAsConstantImm(Imm))
      return isShiftedInt<12, 1>(Imm);
    return MCOp.isBareSymbolRef();

  }
  case 3: {
  // simm21_lsb0_jal

    int64_t Imm;
    if (MCOp.evaluateAsConstantImm(Imm))
      return isShiftedInt<20, 1>(Imm);
    return MCOp.isBareSymbolRef();

  }
  case 4: {
  // uimm20_lui

    int64_t Imm;
    if (MCOp.evaluateAsConstantImm(Imm))
      return isUInt<20>(Imm);
    return MCOp.isBareSymbolRef();

  }
  case 5: {
  // uimmlog2xlen

    int64_t Imm;
    if (!MCOp.evaluateAsConstantImm(Imm))
      return false;
    if (STI.getTargetTriple().isArch64Bit())
      return  isUInt<6>(Imm);
    return isUInt<5>(Imm);

  }
  }
}

static bool uncompressInst(MCInst& OutInst,
                           const MCInst &MI,
                           const MCRegisterInfo &MRI,
                           const MCSubtargetInfo &STI) {
  switch (MI.getOpcode()) {
    default: return false;
    case RISCV::C_ADD: {
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(2).getReg()))) {
      // add	$rd, $rs1, $rs2
      OutInst.setOpcode(RISCV::ADD);
      // Operand: rd
      OutInst.addOperand(MI.getOperand(0));
      // Operand: rs1
      OutInst.addOperand(MI.getOperand(0));
      // Operand: rs2
      OutInst.addOperand(MI.getOperand(2));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(2).getReg())) &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(0).getReg()))) {
      // add	$rd, $rs1, $rs2
      OutInst.setOpcode(RISCV::ADD);
      // Operand: rd
      OutInst.addOperand(MI.getOperand(0));
      // Operand: rs1
      OutInst.addOperand(MI.getOperand(2));
      // Operand: rs2
      OutInst.addOperand(MI.getOperand(0));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
      break;
    } // case C_ADD
    case RISCV::C_ADDI: {
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(0).getReg())) &&
      RISCVValidateMCOperand(MI.getOperand(2), STI, 1)) {
      // addi	$rd, $rs1, $imm12
      OutInst.setOpcode(RISCV::ADDI);
      // Operand: rd
      OutInst.addOperand(MI.getOperand(0));
      // Operand: rs1
      OutInst.addOperand(MI.getOperand(0));
      // Operand: imm12
      OutInst.addOperand(MI.getOperand(2));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
      break;
    } // case C_ADDI
    case RISCV::C_ADDI16SP: {
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MI.getOperand(0).getReg() == RISCV::X2) &&
      (MI.getOperand(1).getReg() == RISCV::X2) &&
      RISCVValidateMCOperand(MI.getOperand(2), STI, 1)) {
      // addi	$rd, $rs1, $imm12
      OutInst.setOpcode(RISCV::ADDI);
      // Operand: rd
      OutInst.addOperand(MCOperand::createReg(RISCV::X2));
      // Operand: rs1
      OutInst.addOperand(MCOperand::createReg(RISCV::X2));
      // Operand: imm12
      OutInst.addOperand(MI.getOperand(2));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
      break;
    } // case C_ADDI16SP
    case RISCV::C_ADDI4SPN: {
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(1).getReg())) &&
      RISCVValidateMCOperand(MI.getOperand(2), STI, 1)) {
      // addi	$rd, $rs1, $imm12
      OutInst.setOpcode(RISCV::ADDI);
      // Operand: rd
      OutInst.addOperand(MI.getOperand(0));
      // Operand: rs1
      OutInst.addOperand(MI.getOperand(1));
      // Operand: imm12
      OutInst.addOperand(MI.getOperand(2));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
      break;
    } // case C_ADDI4SPN
    case RISCV::C_ADDIW: {
    if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
      STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(0).getReg())) &&
      RISCVValidateMCOperand(MI.getOperand(2), STI, 1)) {
      // addiw	$rd, $rs1, $imm12
      OutInst.setOpcode(RISCV::ADDIW);
      // Operand: rd
      OutInst.addOperand(MI.getOperand(0));
      // Operand: rs1
      OutInst.addOperand(MI.getOperand(0));
      // Operand: imm12
      OutInst.addOperand(MI.getOperand(2));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
      break;
    } // case C_ADDIW
    case RISCV::C_ADDW: {
    if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
      STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(2).getReg()))) {
      // addw	$rd, $rs1, $rs2
      OutInst.setOpcode(RISCV::ADDW);
      // Operand: rd
      OutInst.addOperand(MI.getOperand(0));
      // Operand: rs1
      OutInst.addOperand(MI.getOperand(0));
      // Operand: rs2
      OutInst.addOperand(MI.getOperand(2));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
    if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
      STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(2).getReg())) &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(0).getReg()))) {
      // addw	$rd, $rs1, $rs2
      OutInst.setOpcode(RISCV::ADDW);
      // Operand: rd
      OutInst.addOperand(MI.getOperand(0));
      // Operand: rs1
      OutInst.addOperand(MI.getOperand(2));
      // Operand: rs2
      OutInst.addOperand(MI.getOperand(0));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
      break;
    } // case C_ADDW
    case RISCV::C_AND: {
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(2).getReg()))) {
      // and	$rd, $rs1, $rs2
      OutInst.setOpcode(RISCV::AND);
      // Operand: rd
      OutInst.addOperand(MI.getOperand(0));
      // Operand: rs1
      OutInst.addOperand(MI.getOperand(0));
      // Operand: rs2
      OutInst.addOperand(MI.getOperand(2));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(2).getReg())) &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(0).getReg()))) {
      // and	$rd, $rs1, $rs2
      OutInst.setOpcode(RISCV::AND);
      // Operand: rd
      OutInst.addOperand(MI.getOperand(0));
      // Operand: rs1
      OutInst.addOperand(MI.getOperand(2));
      // Operand: rs2
      OutInst.addOperand(MI.getOperand(0));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
      break;
    } // case C_AND
    case RISCV::C_ANDI: {
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(0).getReg())) &&
      RISCVValidateMCOperand(MI.getOperand(2), STI, 1)) {
      // andi	$rd, $rs1, $imm12
      OutInst.setOpcode(RISCV::ANDI);
      // Operand: rd
      OutInst.addOperand(MI.getOperand(0));
      // Operand: rs1
      OutInst.addOperand(MI.getOperand(0));
      // Operand: imm12
      OutInst.addOperand(MI.getOperand(2));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
      break;
    } // case C_ANDI
    case RISCV::C_BEQZ: {
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(0).getReg())) &&
      RISCVValidateMCOperand(MI.getOperand(1), STI, 2)) {
      // beq	$rs1, $rs2, $imm12
      OutInst.setOpcode(RISCV::BEQ);
      // Operand: rs1
      OutInst.addOperand(MI.getOperand(0));
      // Operand: rs2
      OutInst.addOperand(MCOperand::createReg(RISCV::X0));
      // Operand: imm12
      OutInst.addOperand(MI.getOperand(1));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
      break;
    } // case C_BEQZ
    case RISCV::C_BNEZ: {
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(0).getReg())) &&
      RISCVValidateMCOperand(MI.getOperand(1), STI, 2)) {
      // bne	$rs1, $rs2, $imm12
      OutInst.setOpcode(RISCV::BNE);
      // Operand: rs1
      OutInst.addOperand(MI.getOperand(0));
      // Operand: rs2
      OutInst.addOperand(MCOperand::createReg(RISCV::X0));
      // Operand: imm12
      OutInst.addOperand(MI.getOperand(1));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
      break;
    } // case C_BNEZ
    case RISCV::C_EBREAK: {
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC]) {
      // ebreak
      OutInst.setOpcode(RISCV::EBREAK);
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
      break;
    } // case C_EBREAK
    case RISCV::C_FLD: {
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      STI.getFeatureBits()[RISCV::FeatureStdExtD] &&
      (MRI.getRegClass(RISCV::FPR64RegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(1).getReg())) &&
      RISCVValidateMCOperand(MI.getOperand(2), STI, 1)) {
      // fld	$rd, ${imm12}(${rs1})
      OutInst.setOpcode(RISCV::FLD);
      // Operand: rd
      OutInst.addOperand(MI.getOperand(0));
      // Operand: rs1
      OutInst.addOperand(MI.getOperand(1));
      // Operand: imm12
      OutInst.addOperand(MI.getOperand(2));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
      break;
    } // case C_FLD
    case RISCV::C_FLDSP: {
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      STI.getFeatureBits()[RISCV::FeatureStdExtD] &&
      (MRI.getRegClass(RISCV::FPR64RegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(1).getReg())) &&
      RISCVValidateMCOperand(MI.getOperand(2), STI, 1)) {
      // fld	$rd, ${imm12}(${rs1})
      OutInst.setOpcode(RISCV::FLD);
      // Operand: rd
      OutInst.addOperand(MI.getOperand(0));
      // Operand: rs1
      OutInst.addOperand(MI.getOperand(1));
      // Operand: imm12
      OutInst.addOperand(MI.getOperand(2));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
      break;
    } // case C_FLDSP
    case RISCV::C_FLW: {
    if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
      STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      STI.getFeatureBits()[RISCV::FeatureStdExtF] &&
      (MRI.getRegClass(RISCV::FPR32RegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(1).getReg())) &&
      RISCVValidateMCOperand(MI.getOperand(2), STI, 1)) {
      // flw	$rd, ${imm12}(${rs1})
      OutInst.setOpcode(RISCV::FLW);
      // Operand: rd
      OutInst.addOperand(MI.getOperand(0));
      // Operand: rs1
      OutInst.addOperand(MI.getOperand(1));
      // Operand: imm12
      OutInst.addOperand(MI.getOperand(2));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
      break;
    } // case C_FLW
    case RISCV::C_FLWSP: {
    if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
      STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      STI.getFeatureBits()[RISCV::FeatureStdExtF] &&
      (MRI.getRegClass(RISCV::FPR32RegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(1).getReg())) &&
      RISCVValidateMCOperand(MI.getOperand(2), STI, 1)) {
      // flw	$rd, ${imm12}(${rs1})
      OutInst.setOpcode(RISCV::FLW);
      // Operand: rd
      OutInst.addOperand(MI.getOperand(0));
      // Operand: rs1
      OutInst.addOperand(MI.getOperand(1));
      // Operand: imm12
      OutInst.addOperand(MI.getOperand(2));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
      break;
    } // case C_FLWSP
    case RISCV::C_FSD: {
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      STI.getFeatureBits()[RISCV::FeatureStdExtD] &&
      (MRI.getRegClass(RISCV::FPR64RegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(1).getReg())) &&
      RISCVValidateMCOperand(MI.getOperand(2), STI, 1)) {
      // fsd	$rs2, ${imm12}(${rs1})
      OutInst.setOpcode(RISCV::FSD);
      // Operand: rs2
      OutInst.addOperand(MI.getOperand(0));
      // Operand: rs1
      OutInst.addOperand(MI.getOperand(1));
      // Operand: imm12
      OutInst.addOperand(MI.getOperand(2));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
      break;
    } // case C_FSD
    case RISCV::C_FSDSP: {
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      STI.getFeatureBits()[RISCV::FeatureStdExtD] &&
      (MRI.getRegClass(RISCV::FPR64RegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(1).getReg())) &&
      RISCVValidateMCOperand(MI.getOperand(2), STI, 1)) {
      // fsd	$rs2, ${imm12}(${rs1})
      OutInst.setOpcode(RISCV::FSD);
      // Operand: rs2
      OutInst.addOperand(MI.getOperand(0));
      // Operand: rs1
      OutInst.addOperand(MI.getOperand(1));
      // Operand: imm12
      OutInst.addOperand(MI.getOperand(2));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
      break;
    } // case C_FSDSP
    case RISCV::C_FSW: {
    if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
      STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      STI.getFeatureBits()[RISCV::FeatureStdExtF] &&
      (MRI.getRegClass(RISCV::FPR32RegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(1).getReg())) &&
      RISCVValidateMCOperand(MI.getOperand(2), STI, 1)) {
      // fsw	$rs2, ${imm12}(${rs1})
      OutInst.setOpcode(RISCV::FSW);
      // Operand: rs2
      OutInst.addOperand(MI.getOperand(0));
      // Operand: rs1
      OutInst.addOperand(MI.getOperand(1));
      // Operand: imm12
      OutInst.addOperand(MI.getOperand(2));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
      break;
    } // case C_FSW
    case RISCV::C_FSWSP: {
    if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
      STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      STI.getFeatureBits()[RISCV::FeatureStdExtF] &&
      (MRI.getRegClass(RISCV::FPR32RegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(1).getReg())) &&
      RISCVValidateMCOperand(MI.getOperand(2), STI, 1)) {
      // fsw	$rs2, ${imm12}(${rs1})
      OutInst.setOpcode(RISCV::FSW);
      // Operand: rs2
      OutInst.addOperand(MI.getOperand(0));
      // Operand: rs1
      OutInst.addOperand(MI.getOperand(1));
      // Operand: imm12
      OutInst.addOperand(MI.getOperand(2));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
      break;
    } // case C_FSWSP
    case RISCV::C_J: {
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      RISCVValidateMCOperand(MI.getOperand(0), STI, 3)) {
      // jal	$rd, $imm20
      OutInst.setOpcode(RISCV::JAL);
      // Operand: rd
      OutInst.addOperand(MCOperand::createReg(RISCV::X0));
      // Operand: imm20
      OutInst.addOperand(MI.getOperand(0));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
      break;
    } // case C_J
    case RISCV::C_JAL: {
    if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
      STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      RISCVValidateMCOperand(MI.getOperand(0), STI, 3)) {
      // jal	$rd, $imm20
      OutInst.setOpcode(RISCV::JAL);
      // Operand: rd
      OutInst.addOperand(MCOperand::createReg(RISCV::X1));
      // Operand: imm20
      OutInst.addOperand(MI.getOperand(0));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
      break;
    } // case C_JAL
    case RISCV::C_JALR: {
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(0).getReg())) &&
      RISCVValidateMCOperand(MCOperand::createImm(0), STI, 1)) {
      // jalr	$rd, ${imm12}(${rs1})
      OutInst.setOpcode(RISCV::JALR);
      // Operand: rd
      OutInst.addOperand(MCOperand::createReg(RISCV::X1));
      // Operand: rs1
      OutInst.addOperand(MI.getOperand(0));
      // Operand: imm12
      OutInst.addOperand(MCOperand::createImm(0));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
      break;
    } // case C_JALR
    case RISCV::C_JR: {
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(0).getReg())) &&
      RISCVValidateMCOperand(MCOperand::createImm(0), STI, 1)) {
      // jalr	$rd, ${imm12}(${rs1})
      OutInst.setOpcode(RISCV::JALR);
      // Operand: rd
      OutInst.addOperand(MCOperand::createReg(RISCV::X0));
      // Operand: rs1
      OutInst.addOperand(MI.getOperand(0));
      // Operand: imm12
      OutInst.addOperand(MCOperand::createImm(0));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
      break;
    } // case C_JR
    case RISCV::C_LD: {
    if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
      STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(1).getReg())) &&
      RISCVValidateMCOperand(MI.getOperand(2), STI, 1)) {
      // ld	$rd, ${imm12}(${rs1})
      OutInst.setOpcode(RISCV::LD);
      // Operand: rd
      OutInst.addOperand(MI.getOperand(0));
      // Operand: rs1
      OutInst.addOperand(MI.getOperand(1));
      // Operand: imm12
      OutInst.addOperand(MI.getOperand(2));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
      break;
    } // case C_LD
    case RISCV::C_LDSP: {
    if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
      STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(1).getReg())) &&
      RISCVValidateMCOperand(MI.getOperand(2), STI, 1)) {
      // ld	$rd, ${imm12}(${rs1})
      OutInst.setOpcode(RISCV::LD);
      // Operand: rd
      OutInst.addOperand(MI.getOperand(0));
      // Operand: rs1
      OutInst.addOperand(MI.getOperand(1));
      // Operand: imm12
      OutInst.addOperand(MI.getOperand(2));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
      break;
    } // case C_LDSP
    case RISCV::C_LI: {
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(0).getReg())) &&
      RISCVValidateMCOperand(MI.getOperand(1), STI, 1)) {
      // addi	$rd, $rs1, $imm12
      OutInst.setOpcode(RISCV::ADDI);
      // Operand: rd
      OutInst.addOperand(MI.getOperand(0));
      // Operand: rs1
      OutInst.addOperand(MCOperand::createReg(RISCV::X0));
      // Operand: imm12
      OutInst.addOperand(MI.getOperand(1));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
    if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
      STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(0).getReg())) &&
      RISCVValidateMCOperand(MI.getOperand(1), STI, 1)) {
      // addiw	$rd, $rs1, $imm12
      OutInst.setOpcode(RISCV::ADDIW);
      // Operand: rd
      OutInst.addOperand(MI.getOperand(0));
      // Operand: rs1
      OutInst.addOperand(MCOperand::createReg(RISCV::X0));
      // Operand: imm12
      OutInst.addOperand(MI.getOperand(1));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
      break;
    } // case C_LI
    case RISCV::C_LUI: {
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(0).getReg())) &&
      RISCVValidateMCOperand(MI.getOperand(1), STI, 4)) {
      // lui	$rd, $imm20
      OutInst.setOpcode(RISCV::LUI);
      // Operand: rd
      OutInst.addOperand(MI.getOperand(0));
      // Operand: imm20
      OutInst.addOperand(MI.getOperand(1));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
      break;
    } // case C_LUI
    case RISCV::C_LW: {
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(1).getReg())) &&
      RISCVValidateMCOperand(MI.getOperand(2), STI, 1)) {
      // lw	$rd, ${imm12}(${rs1})
      OutInst.setOpcode(RISCV::LW);
      // Operand: rd
      OutInst.addOperand(MI.getOperand(0));
      // Operand: rs1
      OutInst.addOperand(MI.getOperand(1));
      // Operand: imm12
      OutInst.addOperand(MI.getOperand(2));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
      break;
    } // case C_LW
    case RISCV::C_LWSP: {
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(1).getReg())) &&
      RISCVValidateMCOperand(MI.getOperand(2), STI, 1)) {
      // lw	$rd, ${imm12}(${rs1})
      OutInst.setOpcode(RISCV::LW);
      // Operand: rd
      OutInst.addOperand(MI.getOperand(0));
      // Operand: rs1
      OutInst.addOperand(MI.getOperand(1));
      // Operand: imm12
      OutInst.addOperand(MI.getOperand(2));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
      break;
    } // case C_LWSP
    case RISCV::C_MV: {
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(1).getReg()))) {
      // add	$rd, $rs1, $rs2
      OutInst.setOpcode(RISCV::ADD);
      // Operand: rd
      OutInst.addOperand(MI.getOperand(0));
      // Operand: rs1
      OutInst.addOperand(MCOperand::createReg(RISCV::X0));
      // Operand: rs2
      OutInst.addOperand(MI.getOperand(1));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(1).getReg()))) {
      // add	$rd, $rs1, $rs2
      OutInst.setOpcode(RISCV::ADD);
      // Operand: rd
      OutInst.addOperand(MI.getOperand(0));
      // Operand: rs1
      OutInst.addOperand(MI.getOperand(1));
      // Operand: rs2
      OutInst.addOperand(MCOperand::createReg(RISCV::X0));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(1).getReg())) &&
      RISCVValidateMCOperand(MCOperand::createImm(0), STI, 1)) {
      // addi	$rd, $rs1, $imm12
      OutInst.setOpcode(RISCV::ADDI);
      // Operand: rd
      OutInst.addOperand(MI.getOperand(0));
      // Operand: rs1
      OutInst.addOperand(MI.getOperand(1));
      // Operand: imm12
      OutInst.addOperand(MCOperand::createImm(0));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
      break;
    } // case C_MV
    case RISCV::C_NOP: {
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      RISCVValidateMCOperand(MCOperand::createImm(0), STI, 1)) {
      // addi	$rd, $rs1, $imm12
      OutInst.setOpcode(RISCV::ADDI);
      // Operand: rd
      OutInst.addOperand(MCOperand::createReg(RISCV::X0));
      // Operand: rs1
      OutInst.addOperand(MCOperand::createReg(RISCV::X0));
      // Operand: imm12
      OutInst.addOperand(MCOperand::createImm(0));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
      break;
    } // case C_NOP
    case RISCV::C_OR: {
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(2).getReg()))) {
      // or	$rd, $rs1, $rs2
      OutInst.setOpcode(RISCV::OR);
      // Operand: rd
      OutInst.addOperand(MI.getOperand(0));
      // Operand: rs1
      OutInst.addOperand(MI.getOperand(0));
      // Operand: rs2
      OutInst.addOperand(MI.getOperand(2));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(2).getReg())) &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(0).getReg()))) {
      // or	$rd, $rs1, $rs2
      OutInst.setOpcode(RISCV::OR);
      // Operand: rd
      OutInst.addOperand(MI.getOperand(0));
      // Operand: rs1
      OutInst.addOperand(MI.getOperand(2));
      // Operand: rs2
      OutInst.addOperand(MI.getOperand(0));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
      break;
    } // case C_OR
    case RISCV::C_SD: {
    if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
      STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(1).getReg())) &&
      RISCVValidateMCOperand(MI.getOperand(2), STI, 1)) {
      // sd	$rs2, ${imm12}(${rs1})
      OutInst.setOpcode(RISCV::SD);
      // Operand: rs2
      OutInst.addOperand(MI.getOperand(0));
      // Operand: rs1
      OutInst.addOperand(MI.getOperand(1));
      // Operand: imm12
      OutInst.addOperand(MI.getOperand(2));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
      break;
    } // case C_SD
    case RISCV::C_SDSP: {
    if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
      STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(1).getReg())) &&
      RISCVValidateMCOperand(MI.getOperand(2), STI, 1)) {
      // sd	$rs2, ${imm12}(${rs1})
      OutInst.setOpcode(RISCV::SD);
      // Operand: rs2
      OutInst.addOperand(MI.getOperand(0));
      // Operand: rs1
      OutInst.addOperand(MI.getOperand(1));
      // Operand: imm12
      OutInst.addOperand(MI.getOperand(2));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
      break;
    } // case C_SDSP
    case RISCV::C_SLLI: {
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(0).getReg())) &&
      RISCVValidateMCOperand(MI.getOperand(2), STI, 5)) {
      // slli	$rd, $rs1, $shamt
      OutInst.setOpcode(RISCV::SLLI);
      // Operand: rd
      OutInst.addOperand(MI.getOperand(0));
      // Operand: rs1
      OutInst.addOperand(MI.getOperand(0));
      // Operand: shamt
      OutInst.addOperand(MI.getOperand(2));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
      break;
    } // case C_SLLI
    case RISCV::C_SRAI: {
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(0).getReg())) &&
      RISCVValidateMCOperand(MI.getOperand(2), STI, 5)) {
      // srai	$rd, $rs1, $shamt
      OutInst.setOpcode(RISCV::SRAI);
      // Operand: rd
      OutInst.addOperand(MI.getOperand(0));
      // Operand: rs1
      OutInst.addOperand(MI.getOperand(0));
      // Operand: shamt
      OutInst.addOperand(MI.getOperand(2));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
      break;
    } // case C_SRAI
    case RISCV::C_SRLI: {
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(0).getReg())) &&
      RISCVValidateMCOperand(MI.getOperand(2), STI, 5)) {
      // srli	$rd, $rs1, $shamt
      OutInst.setOpcode(RISCV::SRLI);
      // Operand: rd
      OutInst.addOperand(MI.getOperand(0));
      // Operand: rs1
      OutInst.addOperand(MI.getOperand(0));
      // Operand: shamt
      OutInst.addOperand(MI.getOperand(2));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
      break;
    } // case C_SRLI
    case RISCV::C_SUB: {
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(2).getReg()))) {
      // sub	$rd, $rs1, $rs2
      OutInst.setOpcode(RISCV::SUB);
      // Operand: rd
      OutInst.addOperand(MI.getOperand(0));
      // Operand: rs1
      OutInst.addOperand(MI.getOperand(0));
      // Operand: rs2
      OutInst.addOperand(MI.getOperand(2));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
      break;
    } // case C_SUB
    case RISCV::C_SUBW: {
    if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
      STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(2).getReg()))) {
      // subw	$rd, $rs1, $rs2
      OutInst.setOpcode(RISCV::SUBW);
      // Operand: rd
      OutInst.addOperand(MI.getOperand(0));
      // Operand: rs1
      OutInst.addOperand(MI.getOperand(0));
      // Operand: rs2
      OutInst.addOperand(MI.getOperand(2));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
      break;
    } // case C_SUBW
    case RISCV::C_SW: {
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(1).getReg())) &&
      RISCVValidateMCOperand(MI.getOperand(2), STI, 1)) {
      // sw	$rs2, ${imm12}(${rs1})
      OutInst.setOpcode(RISCV::SW);
      // Operand: rs2
      OutInst.addOperand(MI.getOperand(0));
      // Operand: rs1
      OutInst.addOperand(MI.getOperand(1));
      // Operand: imm12
      OutInst.addOperand(MI.getOperand(2));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
      break;
    } // case C_SW
    case RISCV::C_SWSP: {
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(1).getReg())) &&
      RISCVValidateMCOperand(MI.getOperand(2), STI, 1)) {
      // sw	$rs2, ${imm12}(${rs1})
      OutInst.setOpcode(RISCV::SW);
      // Operand: rs2
      OutInst.addOperand(MI.getOperand(0));
      // Operand: rs1
      OutInst.addOperand(MI.getOperand(1));
      // Operand: imm12
      OutInst.addOperand(MI.getOperand(2));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
      break;
    } // case C_SWSP
    case RISCV::C_UNIMP: {
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC]) {
      // unimp
      OutInst.setOpcode(RISCV::UNIMP);
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
      break;
    } // case C_UNIMP
    case RISCV::C_XOR: {
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(2).getReg()))) {
      // xor	$rd, $rs1, $rs2
      OutInst.setOpcode(RISCV::XOR);
      // Operand: rd
      OutInst.addOperand(MI.getOperand(0));
      // Operand: rs1
      OutInst.addOperand(MI.getOperand(0));
      // Operand: rs2
      OutInst.addOperand(MI.getOperand(2));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(2).getReg())) &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(0).getReg()))) {
      // xor	$rd, $rs1, $rs2
      OutInst.setOpcode(RISCV::XOR);
      // Operand: rd
      OutInst.addOperand(MI.getOperand(0));
      // Operand: rs1
      OutInst.addOperand(MI.getOperand(2));
      // Operand: rs2
      OutInst.addOperand(MI.getOperand(0));
      OutInst.setLoc(MI.getLoc());
      return true;
    } // if

    } // case C_XOR
  } // switch
  return false;
}

#endif //GEN_UNCOMPRESS_INSTR


#ifdef GEN_CHECK_COMPRESS_INSTR
#undef GEN_CHECK_COMPRESS_INSTR

static bool RISCVValidateMachineOperand(const MachineOperand &MO,
                  const RISCVSubtarget *Subtarget,
                  unsigned PredicateIndex) {
  int64_t Imm = MO.getImm();
  switch (PredicateIndex) {
  default:
    llvm_unreachable("Unknown ImmLeaf Predicate kind");
    break;
  case 1: {
  // simm6nonzero
  return (Imm != 0) && isInt<6>(Imm);
  }
  case 2: {
  // simm10_lsb0000nonzero
  return (Imm != 0) && isShiftedInt<6, 4>(Imm);
  }
  case 3: {
  // uimm10_lsb00nonzero
  return isShiftedUInt<8, 2>(Imm) && (Imm != 0);
  }
  case 4: {
  // simm6
  return isInt<6>(Imm);
  }
  case 5: {
  // simm9_lsb0
  return isShiftedInt<8, 1>(Imm);
  }
  case 6: {
  // uimm8_lsb000
  return isShiftedUInt<5, 3>(Imm);
  }
  case 7: {
  // uimm9_lsb000
  return isShiftedUInt<6, 3>(Imm);
  }
  case 8: {
  // uimm7_lsb00
  return isShiftedUInt<5, 2>(Imm);
  }
  case 9: {
  // uimm8_lsb00
  return isShiftedUInt<6, 2>(Imm);
  }
  case 10: {
  // simm12_lsb0
  return isShiftedInt<11, 1>(Imm);
  }
  case 11: {
  // c_lui_imm
  return (Imm != 0) &&
                                 (isUInt<5>(Imm) ||
                                  (Imm >= 0xfffe0 && Imm <= 0xfffff));
  }
  case 12: {
  // uimmlog2xlennonzero

  if (Subtarget->is64Bit())
    return isUInt<6>(Imm) && (Imm != 0);
  return isUInt<5>(Imm) && (Imm != 0);

  }
  }
}

static bool isCompressibleInst(const MachineInstr& MI,
                           const RISCVSubtarget *Subtarget,
                           const MCRegisterInfo &MRI,
                           const MCSubtargetInfo &STI) {
  switch (MI.getOpcode()) {
    default: return false;
    case RISCV::ADD: {
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MI.getOperand(1).getReg() ==  MI.getOperand(0).getReg()) &&
      (MRI.getRegClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(1).getReg())) &&
      (MRI.getRegClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(2).getReg()))) {
      // c.add	$rs1, $rs2
      // Operand: rs1_wb
      // Operand: rs1
      // Operand: rs2
      return true;
    } // if
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MI.getOperand(2).getReg() ==  MI.getOperand(0).getReg()) &&
      (MRI.getRegClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(2).getReg())) &&
      (MRI.getRegClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(1).getReg()))) {
      // c.add	$rs1, $rs2
      // Operand: rs1_wb
      // Operand: rs1
      // Operand: rs2
      return true;
    } // if
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MI.getOperand(1).getReg() == RISCV::X0) &&
      (MRI.getRegClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(2).getReg()))) {
      // c.mv	$rs1, $rs2
      // Operand: rs1
      // Operand: rs2
      return true;
    } // if
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MI.getOperand(2).getReg() == RISCV::X0) &&
      (MRI.getRegClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(1).getReg()))) {
      // c.mv	$rs1, $rs2
      // Operand: rs1
      // Operand: rs2
      return true;
    } // if
      break;
    } // case ADD
    case RISCV::ADDI: {
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MI.getOperand(1).getReg() ==  MI.getOperand(0).getReg()) &&
      (MRI.getRegClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(1).getReg())) &&
      MI.getOperand(2).isImm() &&
      RISCVValidateMachineOperand(MI.getOperand(2), Subtarget, 1)) {
      // c.addi	$rd, $imm
      // Operand: rd_wb
      // Operand: rd
      // Operand: imm
      return true;
    } // if
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MI.getOperand(0).getReg() == RISCV::X2) &&
      (MI.getOperand(1).getReg() == RISCV::X2) &&
      MI.getOperand(2).isImm() &&
      RISCVValidateMachineOperand(MI.getOperand(2), Subtarget, 2)) {
      // c.addi16sp	$rd, $imm
      // Operand: rd_wb
      // Operand: rd
      // Operand: imm
      return true;
    } // if
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MRI.getRegClass(RISCV::GPRCRegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::SPRegClassID).contains(MI.getOperand(1).getReg())) &&
      MI.getOperand(2).isImm() &&
      RISCVValidateMachineOperand(MI.getOperand(2), Subtarget, 3)) {
      // c.addi4spn	$rd, $rs1, $imm
      // Operand: rd
      // Operand: rs1
      // Operand: imm
      return true;
    } // if
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MI.getOperand(1).getReg() == RISCV::X0) &&
      (MRI.getRegClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(0).getReg())) &&
      MI.getOperand(2).isImm() &&
      RISCVValidateMachineOperand(MI.getOperand(2), Subtarget, 4)) {
      // c.li	$rd, $imm
      // Operand: rd
      // Operand: imm
      return true;
    } // if
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MI.getOperand(2).isImm()) &&
      (MI.getOperand(2).getImm() == 0) &&
      (MRI.getRegClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(1).getReg()))) {
      // c.mv	$rs1, $rs2
      // Operand: rs1
      // Operand: rs2
      return true;
    } // if
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MI.getOperand(0).getReg() == RISCV::X0) &&
      (MI.getOperand(1).getReg() == RISCV::X0) &&
      (MI.getOperand(2).isImm()) &&
      (MI.getOperand(2).getImm() == 0)) {
      // c.nop
      return true;
    } // if
      break;
    } // case ADDI
    case RISCV::ADDIW: {
    if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
      STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MI.getOperand(1).getReg() ==  MI.getOperand(0).getReg()) &&
      (MRI.getRegClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(1).getReg())) &&
      MI.getOperand(2).isImm() &&
      RISCVValidateMachineOperand(MI.getOperand(2), Subtarget, 4)) {
      // c.addiw	$rd, $imm
      // Operand: rd_wb
      // Operand: rd
      // Operand: imm
      return true;
    } // if
    if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
      STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MI.getOperand(1).getReg() == RISCV::X0) &&
      (MRI.getRegClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(0).getReg())) &&
      MI.getOperand(2).isImm() &&
      RISCVValidateMachineOperand(MI.getOperand(2), Subtarget, 4)) {
      // c.li	$rd, $imm
      // Operand: rd
      // Operand: imm
      return true;
    } // if
      break;
    } // case ADDIW
    case RISCV::ADDW: {
    if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
      STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MI.getOperand(1).getReg() ==  MI.getOperand(0).getReg()) &&
      (MRI.getRegClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg())) &&
      (MRI.getRegClass(RISCV::GPRCRegClassID).contains(MI.getOperand(2).getReg()))) {
      // c.addw	$rd, $rs2
      // Operand: rd_wb
      // Operand: rd
      // Operand: rs2
      return true;
    } // if
    if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
      STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MI.getOperand(2).getReg() ==  MI.getOperand(0).getReg()) &&
      (MRI.getRegClass(RISCV::GPRCRegClassID).contains(MI.getOperand(2).getReg())) &&
      (MRI.getRegClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg()))) {
      // c.addw	$rd, $rs2
      // Operand: rd_wb
      // Operand: rd
      // Operand: rs2
      return true;
    } // if
      break;
    } // case ADDW
    case RISCV::AND: {
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MI.getOperand(1).getReg() ==  MI.getOperand(0).getReg()) &&
      (MRI.getRegClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg())) &&
      (MRI.getRegClass(RISCV::GPRCRegClassID).contains(MI.getOperand(2).getReg()))) {
      // c.and	$rd, $rs2
      // Operand: rd_wb
      // Operand: rd
      // Operand: rs2
      return true;
    } // if
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MI.getOperand(2).getReg() ==  MI.getOperand(0).getReg()) &&
      (MRI.getRegClass(RISCV::GPRCRegClassID).contains(MI.getOperand(2).getReg())) &&
      (MRI.getRegClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg()))) {
      // c.and	$rd, $rs2
      // Operand: rd_wb
      // Operand: rd
      // Operand: rs2
      return true;
    } // if
      break;
    } // case AND
    case RISCV::ANDI: {
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MI.getOperand(1).getReg() ==  MI.getOperand(0).getReg()) &&
      (MRI.getRegClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg())) &&
      MI.getOperand(2).isImm() &&
      RISCVValidateMachineOperand(MI.getOperand(2), Subtarget, 4)) {
      // c.andi	$rs1, $imm
      // Operand: rs1_wb
      // Operand: rs1
      // Operand: imm
      return true;
    } // if
      break;
    } // case ANDI
    case RISCV::BEQ: {
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MI.getOperand(1).getReg() == RISCV::X0) &&
      (MRI.getRegClass(RISCV::GPRCRegClassID).contains(MI.getOperand(0).getReg())) &&
      MI.getOperand(2).isImm() &&
      RISCVValidateMachineOperand(MI.getOperand(2), Subtarget, 5)) {
      // c.beqz	$rs1, $imm
      // Operand: rs1
      // Operand: imm
      return true;
    } // if
      break;
    } // case BEQ
    case RISCV::BNE: {
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MI.getOperand(1).getReg() == RISCV::X0) &&
      (MRI.getRegClass(RISCV::GPRCRegClassID).contains(MI.getOperand(0).getReg())) &&
      MI.getOperand(2).isImm() &&
      RISCVValidateMachineOperand(MI.getOperand(2), Subtarget, 5)) {
      // c.bnez	$rs1, $imm
      // Operand: rs1
      // Operand: imm
      return true;
    } // if
      break;
    } // case BNE
    case RISCV::EBREAK: {
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC]) {
      // c.ebreak
      return true;
    } // if
      break;
    } // case EBREAK
    case RISCV::FLD: {
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      STI.getFeatureBits()[RISCV::FeatureStdExtD] &&
      (MRI.getRegClass(RISCV::FPR64CRegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg())) &&
      MI.getOperand(2).isImm() &&
      RISCVValidateMachineOperand(MI.getOperand(2), Subtarget, 6)) {
      // c.fld	$rd, ${imm}(${rs1})
      // Operand: rd
      // Operand: rs1
      // Operand: imm
      return true;
    } // if
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      STI.getFeatureBits()[RISCV::FeatureStdExtD] &&
      (MRI.getRegClass(RISCV::FPR64RegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::SPRegClassID).contains(MI.getOperand(1).getReg())) &&
      MI.getOperand(2).isImm() &&
      RISCVValidateMachineOperand(MI.getOperand(2), Subtarget, 7)) {
      // c.fldsp	$rd, ${imm}(${rs1})
      // Operand: rd
      // Operand: rs1
      // Operand: imm
      return true;
    } // if
      break;
    } // case FLD
    case RISCV::FLW: {
    if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
      STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      STI.getFeatureBits()[RISCV::FeatureStdExtF] &&
      (MRI.getRegClass(RISCV::FPR32CRegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg())) &&
      MI.getOperand(2).isImm() &&
      RISCVValidateMachineOperand(MI.getOperand(2), Subtarget, 8)) {
      // c.flw	$rd, ${imm}(${rs1})
      // Operand: rd
      // Operand: rs1
      // Operand: imm
      return true;
    } // if
    if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
      STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      STI.getFeatureBits()[RISCV::FeatureStdExtF] &&
      (MRI.getRegClass(RISCV::FPR32RegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::SPRegClassID).contains(MI.getOperand(1).getReg())) &&
      MI.getOperand(2).isImm() &&
      RISCVValidateMachineOperand(MI.getOperand(2), Subtarget, 9)) {
      // c.flwsp	$rd, ${imm}(${rs1})
      // Operand: rd
      // Operand: rs1
      // Operand: imm
      return true;
    } // if
      break;
    } // case FLW
    case RISCV::FSD: {
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      STI.getFeatureBits()[RISCV::FeatureStdExtD] &&
      (MRI.getRegClass(RISCV::FPR64CRegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg())) &&
      MI.getOperand(2).isImm() &&
      RISCVValidateMachineOperand(MI.getOperand(2), Subtarget, 6)) {
      // c.fsd	$rs2, ${imm}(${rs1})
      // Operand: rs2
      // Operand: rs1
      // Operand: imm
      return true;
    } // if
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      STI.getFeatureBits()[RISCV::FeatureStdExtD] &&
      (MRI.getRegClass(RISCV::FPR64RegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::SPRegClassID).contains(MI.getOperand(1).getReg())) &&
      MI.getOperand(2).isImm() &&
      RISCVValidateMachineOperand(MI.getOperand(2), Subtarget, 7)) {
      // c.fsdsp	$rs2, ${imm}(${rs1})
      // Operand: rs2
      // Operand: rs1
      // Operand: imm
      return true;
    } // if
      break;
    } // case FSD
    case RISCV::FSW: {
    if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
      STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      STI.getFeatureBits()[RISCV::FeatureStdExtF] &&
      (MRI.getRegClass(RISCV::FPR32CRegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg())) &&
      MI.getOperand(2).isImm() &&
      RISCVValidateMachineOperand(MI.getOperand(2), Subtarget, 8)) {
      // c.fsw	$rs2, ${imm}(${rs1})
      // Operand: rs2
      // Operand: rs1
      // Operand: imm
      return true;
    } // if
    if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
      STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      STI.getFeatureBits()[RISCV::FeatureStdExtF] &&
      (MRI.getRegClass(RISCV::FPR32RegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::SPRegClassID).contains(MI.getOperand(1).getReg())) &&
      MI.getOperand(2).isImm() &&
      RISCVValidateMachineOperand(MI.getOperand(2), Subtarget, 9)) {
      // c.fswsp	$rs2, ${imm}(${rs1})
      // Operand: rs2
      // Operand: rs1
      // Operand: imm
      return true;
    } // if
      break;
    } // case FSW
    case RISCV::JAL: {
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MI.getOperand(0).getReg() == RISCV::X0) &&
      MI.getOperand(1).isImm() &&
      RISCVValidateMachineOperand(MI.getOperand(1), Subtarget, 10)) {
      // c.j	$offset
      // Operand: offset
      return true;
    } // if
    if (!STI.getFeatureBits()[RISCV::Feature64Bit] &&
      STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MI.getOperand(0).getReg() == RISCV::X1) &&
      MI.getOperand(1).isImm() &&
      RISCVValidateMachineOperand(MI.getOperand(1), Subtarget, 10)) {
      // c.jal	$offset
      // Operand: offset
      return true;
    } // if
      break;
    } // case JAL
    case RISCV::JALR: {
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MI.getOperand(0).getReg() == RISCV::X1) &&
      (MI.getOperand(2).isImm()) &&
      (MI.getOperand(2).getImm() == 0) &&
      (MRI.getRegClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(1).getReg()))) {
      // c.jalr	$rs1
      // Operand: rs1
      return true;
    } // if
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MI.getOperand(0).getReg() == RISCV::X0) &&
      (MI.getOperand(2).isImm()) &&
      (MI.getOperand(2).getImm() == 0) &&
      (MRI.getRegClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(1).getReg()))) {
      // c.jr	$rs1
      // Operand: rs1
      return true;
    } // if
      break;
    } // case JALR
    case RISCV::LD: {
    if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
      STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MRI.getRegClass(RISCV::GPRCRegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg())) &&
      MI.getOperand(2).isImm() &&
      RISCVValidateMachineOperand(MI.getOperand(2), Subtarget, 6)) {
      // c.ld	$rd, ${imm}(${rs1})
      // Operand: rd
      // Operand: rs1
      // Operand: imm
      return true;
    } // if
    if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
      STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MRI.getRegClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::SPRegClassID).contains(MI.getOperand(1).getReg())) &&
      MI.getOperand(2).isImm() &&
      RISCVValidateMachineOperand(MI.getOperand(2), Subtarget, 7)) {
      // c.ldsp	$rd, ${imm}(${rs1})
      // Operand: rd
      // Operand: rs1
      // Operand: imm
      return true;
    } // if
      break;
    } // case LD
    case RISCV::LUI: {
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MRI.getRegClass(RISCV::GPRNoX0X2RegClassID).contains(MI.getOperand(0).getReg())) &&
      MI.getOperand(1).isImm() &&
      RISCVValidateMachineOperand(MI.getOperand(1), Subtarget, 11)) {
      // c.lui	$rd, $imm
      // Operand: rd
      // Operand: imm
      return true;
    } // if
      break;
    } // case LUI
    case RISCV::LW: {
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MRI.getRegClass(RISCV::GPRCRegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg())) &&
      MI.getOperand(2).isImm() &&
      RISCVValidateMachineOperand(MI.getOperand(2), Subtarget, 8)) {
      // c.lw	$rd, ${imm}(${rs1})
      // Operand: rd
      // Operand: rs1
      // Operand: imm
      return true;
    } // if
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MRI.getRegClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::SPRegClassID).contains(MI.getOperand(1).getReg())) &&
      MI.getOperand(2).isImm() &&
      RISCVValidateMachineOperand(MI.getOperand(2), Subtarget, 9)) {
      // c.lwsp	$rd, ${imm}(${rs1})
      // Operand: rd
      // Operand: rs1
      // Operand: imm
      return true;
    } // if
      break;
    } // case LW
    case RISCV::OR: {
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MI.getOperand(1).getReg() ==  MI.getOperand(0).getReg()) &&
      (MRI.getRegClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg())) &&
      (MRI.getRegClass(RISCV::GPRCRegClassID).contains(MI.getOperand(2).getReg()))) {
      // c.or	$rd, $rs2
      // Operand: rd_wb
      // Operand: rd
      // Operand: rs2
      return true;
    } // if
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MI.getOperand(2).getReg() ==  MI.getOperand(0).getReg()) &&
      (MRI.getRegClass(RISCV::GPRCRegClassID).contains(MI.getOperand(2).getReg())) &&
      (MRI.getRegClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg()))) {
      // c.or	$rd, $rs2
      // Operand: rd_wb
      // Operand: rd
      // Operand: rs2
      return true;
    } // if
      break;
    } // case OR
    case RISCV::SD: {
    if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
      STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MRI.getRegClass(RISCV::GPRCRegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg())) &&
      MI.getOperand(2).isImm() &&
      RISCVValidateMachineOperand(MI.getOperand(2), Subtarget, 6)) {
      // c.sd	$rs2, ${imm}(${rs1})
      // Operand: rs2
      // Operand: rs1
      // Operand: imm
      return true;
    } // if
    if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
      STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::SPRegClassID).contains(MI.getOperand(1).getReg())) &&
      MI.getOperand(2).isImm() &&
      RISCVValidateMachineOperand(MI.getOperand(2), Subtarget, 7)) {
      // c.sdsp	$rs2, ${imm}(${rs1})
      // Operand: rs2
      // Operand: rs1
      // Operand: imm
      return true;
    } // if
      break;
    } // case SD
    case RISCV::SLLI: {
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MI.getOperand(1).getReg() ==  MI.getOperand(0).getReg()) &&
      (MRI.getRegClass(RISCV::GPRNoX0RegClassID).contains(MI.getOperand(1).getReg())) &&
      MI.getOperand(2).isImm() &&
      RISCVValidateMachineOperand(MI.getOperand(2), Subtarget, 12)) {
      // c.slli	$rd, $imm
      // Operand: rd_wb
      // Operand: rd
      // Operand: imm
      return true;
    } // if
      break;
    } // case SLLI
    case RISCV::SRAI: {
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MI.getOperand(1).getReg() ==  MI.getOperand(0).getReg()) &&
      (MRI.getRegClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg())) &&
      MI.getOperand(2).isImm() &&
      RISCVValidateMachineOperand(MI.getOperand(2), Subtarget, 12)) {
      // c.srai	$rs1, $imm
      // Operand: rs1_wb
      // Operand: rs1
      // Operand: imm
      return true;
    } // if
      break;
    } // case SRAI
    case RISCV::SRLI: {
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MI.getOperand(1).getReg() ==  MI.getOperand(0).getReg()) &&
      (MRI.getRegClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg())) &&
      MI.getOperand(2).isImm() &&
      RISCVValidateMachineOperand(MI.getOperand(2), Subtarget, 12)) {
      // c.srli	$rs1, $imm
      // Operand: rs1_wb
      // Operand: rs1
      // Operand: imm
      return true;
    } // if
      break;
    } // case SRLI
    case RISCV::SUB: {
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MI.getOperand(1).getReg() ==  MI.getOperand(0).getReg()) &&
      (MRI.getRegClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg())) &&
      (MRI.getRegClass(RISCV::GPRCRegClassID).contains(MI.getOperand(2).getReg()))) {
      // c.sub	$rd, $rs2
      // Operand: rd_wb
      // Operand: rd
      // Operand: rs2
      return true;
    } // if
      break;
    } // case SUB
    case RISCV::SUBW: {
    if (STI.getFeatureBits()[RISCV::Feature64Bit] &&
      STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MI.getOperand(1).getReg() ==  MI.getOperand(0).getReg()) &&
      (MRI.getRegClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg())) &&
      (MRI.getRegClass(RISCV::GPRCRegClassID).contains(MI.getOperand(2).getReg()))) {
      // c.subw	$rd, $rs2
      // Operand: rd_wb
      // Operand: rd
      // Operand: rs2
      return true;
    } // if
      break;
    } // case SUBW
    case RISCV::SW: {
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MRI.getRegClass(RISCV::GPRCRegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg())) &&
      MI.getOperand(2).isImm() &&
      RISCVValidateMachineOperand(MI.getOperand(2), Subtarget, 8)) {
      // c.sw	$rs2, ${imm}(${rs1})
      // Operand: rs2
      // Operand: rs1
      // Operand: imm
      return true;
    } // if
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MRI.getRegClass(RISCV::GPRRegClassID).contains(MI.getOperand(0).getReg())) &&
      (MRI.getRegClass(RISCV::SPRegClassID).contains(MI.getOperand(1).getReg())) &&
      MI.getOperand(2).isImm() &&
      RISCVValidateMachineOperand(MI.getOperand(2), Subtarget, 9)) {
      // c.swsp	$rs2, ${imm}(${rs1})
      // Operand: rs2
      // Operand: rs1
      // Operand: imm
      return true;
    } // if
      break;
    } // case SW
    case RISCV::UNIMP: {
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC]) {
      // c.unimp
      return true;
    } // if
      break;
    } // case UNIMP
    case RISCV::XOR: {
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MI.getOperand(1).getReg() ==  MI.getOperand(0).getReg()) &&
      (MRI.getRegClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg())) &&
      (MRI.getRegClass(RISCV::GPRCRegClassID).contains(MI.getOperand(2).getReg()))) {
      // c.xor	$rd, $rs2
      // Operand: rd_wb
      // Operand: rd
      // Operand: rs2
      return true;
    } // if
    if (STI.getFeatureBits()[RISCV::FeatureStdExtC] &&
      (MI.getOperand(2).getReg() ==  MI.getOperand(0).getReg()) &&
      (MRI.getRegClass(RISCV::GPRCRegClassID).contains(MI.getOperand(2).getReg())) &&
      (MRI.getRegClass(RISCV::GPRCRegClassID).contains(MI.getOperand(1).getReg()))) {
      // c.xor	$rd, $rs2
      // Operand: rd_wb
      // Operand: rd
      // Operand: rs2
      return true;
    } // if

    } // case XOR
  } // switch
  return false;
}

#endif //GEN_CHECK_COMPRESS_INSTR