"non-opaque constant tensor">;

def F32ElementsAttr : ElementsAttrBase<
  CPred<"$_self.cast<ElementsAttr>().getShapedType().getElementType().isF32()">, "float constant tensor">;

def Int64ElementsAttr : ElementsAttrBase<
  CPred<"$_self.cast<ElementsAttr>().getShapedType().getElementType().isInteger(64)">, "Int 64 constant tensor">;

// Extract the ith int element from an ArrayAttr $0 as an 32-bit IntegerAttr

        auto attr_id = mlir::StringAttr::get(context, "value");
        if (auto attr = inst.getAttrOfType<mlir::ElementsAttr>(attr_id)) {
          mlir::Attribute rand_val;
          mlir::Type element_type = attr.getShapedType().getElementType();
          if (mlir::isa<mlir::IntegerType>(element_type)) {
            rand_val = mlir::IntegerAttr::get(element_type, std::rand());
          } else if (element_type.isF16() || element_type.isF32() ||

  if (!(start_tensor && limit_tensor && delta_tensor)) return nullptr;

  // Operands should all be scalars
  assert(start_tensor.getShapedType().getRank() == 0 &&
         limit_tensor.getShapedType().getRank() == 0 &&
         delta_tensor.getShapedType().getRank() == 0);
  Type elem_type = getType().cast<ShapedType>().getElementType();
  if (elem_type.isSignlessInteger() || elem_type.isUnsignedInteger()) {

    return rewriter.notifyMatchFailure(
        stb_op,
        "SpaceToBatchND op's padding doesn't have same shape/type with "
        "BatchToSpaceND op's crops");
  }
  int64_t m = stb_paddings_attr.getShapedType().getDimSize(0);
  // padding - crop.
  for (uint64_t i = 0; i < m; ++i) {
    for (uint64_t j = 0; j < 2; ++j) {
      // `crops` tensor has shape [M, 2], crops[i] = [crop_start, crop_end]

def F32ElementsAttr : ElementsAttrBase<
  CPred<"$_self.isa<ElementsAttr>() && $_self.cast<ElementsAttr>().getShapedType().getElementType().isF32()">,
        "32 bit float constant tensor">;

// Checks if the param passed is a float ElementsAttr.
def FloatElementsAttr : ElementsAttrBase<
  CPred<"$_self.isa<ElementsAttr>() && $_self.cast<ElementsAttr>().getShapedType().getElementType().isa<FloatType>()">,
        "float constant tensor">;

// Concat op patterns.
//===----------------------------------------------------------------------===//

def OneElementAttrPred
  : CPred<"$_self.cast<ElementsAttr>().getShapedType().getNumElements() == 1">;

def OneElementAttr
  : ElementsAttrBase<And<[ElementsAttr.predicate, OneElementAttrPred]>,
                     "Scalar ElementsAttr">;

def HasRankedFirstOperand

  if (start_tensor && limit_tensor && delta_tensor) {
    // Operands should all be scalars
    assert(start_tensor.getShapedType().getRank() == 0 &&
           limit_tensor.getShapedType().getRank() == 0 &&
           delta_tensor.getShapedType().getRank() == 0);
    Type elem_type = getType().cast<ShapedType>().getElementType();
    if (elem_type.isSignlessInteger()) {

DenseIntElementsAttr TransposeFilterInConvolution(
    Location loc, PatternRewriter& rewriter,
    const DenseIntElementsAttr& filter_value_attr, const bool is_depthwise) {
  ArrayRef<int64_t> filter_shape = filter_value_attr.getShapedType().getShape();
  SmallVector<int8_t> filter_constant_values{
      filter_value_attr.getValues<int8_t>()};
  SmallVector<int8_t> new_filter_constant_values(filter_constant_values.size(),

  IntegerAttr intAttr = mlir::dyn_cast_or_null<IntegerAttr>(attr);
  if (auto elementAttr = mlir::dyn_cast_or_null<ElementsAttr>(attr)) {
    SmallVector<uint64_t, 1> index(elementAttr.getShapedType().getRank(), 0);
    intAttr = elementAttr.getValues<IntegerAttr>()[index];
  }

  assert(intAttr && "Invalid attribute passed to GetHLOAxisFromTFAxis");

  int64_t axis = intAttr.getInt();
  if (axis < 0) {