%cst0 = "tfl.pseudo_const" () {value = dense<0.0> : tensor<4xf32>} : () -> tensor<4xf32> loc("Const")
  %cst1 = "tfl.pseudo_const" () {value = dense<0.0> : tensor<4xf32>} : () -> tensor<4xf32> loc("Const")
  // expected-error @+1 {{'tfl.lstm' op failed to verify that operand 2 is 2-D}}

// Checks that the `tfl.pseudo_qconst` corresponding to the `stablehlo.constant`
// has the same shape.
// CHECK: %[[QCONST_0:.+]] = "tfl.pseudo_qconst"() <{qtype = tensor<2x3x!quant.uniform<i8:f32:0, {3.000000e+00,3.000000e+00}>>, value = dense<1> : tensor<2x3xi8>}> : () -> tensor<2x3x!quant.uniform<i8:f32:0, {3.000000e+00,3.000000e+00}>>

      // uint8 doesn't require same operands and results scales.
      bool is_uint8 = !sign && (bit_width == 8);
      return !is_uint8;
    }
  }];
}

def TFL_ConstOp : Op<TFL_Dialect, "pseudo_const", [ConstantLike, Pure,
    FirstAttrDerivedResultType,
    QuantizableResult,
    DeclareOpInterfaceMethods<TFL_RuntimeVerification>]> {
  let summary = "Constant pseudo op.";

  let description = [{

                                           Type type, Location loc) {
  // If this is a constant bytes attribute or the result type doesn't match the
  // attribute type, then generate a tfl.pseudo_const.
  if (value.isa<ConstBytesAttr>() ||
      (value.isa<ElementsAttr>() &&
       value.cast<ElementsAttr>().getType() != type))
    return builder.create<ConstOp>(loc, type, value.cast<ElementsAttr>());

  func.return %0: tensor<2xi32>

// CHECK-LABEL: @const

        rhs_qconst_op ? rhs_qconst_op : op.getOperand(1),
        /*fused_activation_function=*/rewriter.getStringAttr("NONE"));
  }
};

// Rewrites quantized `stablehlo.constant` to `tfl.pseudo_qconst`.
class RewriteQuantizedConstantOp
    : public OpRewritePattern<stablehlo::ConstantOp> {
 public:
  using OpRewritePattern<stablehlo::ConstantOp>::OpRewritePattern;