auto attr = mlir::dyn_cast<ArrayAttr>(named_attr.getValue());
  if (!attr) {
    return op->emitError() << "'" << kTfSavedModelIndexPathAttr
                           << "' attribute should be an ArrayAttr";
  }
  for (auto element : attr) {
    if (mlir::isa<StringAttr>(element)) {
      continue;
    }
    if (auto integer = mlir::dyn_cast<IntegerAttr>(element)) {

    auto symRef = callee.get<SymbolRefAttr>();
    return setCalleeAttr(cast<FlatSymbolRefAttr>(symRef));
  }
  // Indirect call, callee Value is the first operand.
  return setOperand(0, callee.get<Value>());
}

LogicalResult ConstantTensorOp::verify() {
  ConstantTensorOp op = *this;
  auto input_type = op.getArg().getType();
  auto output_type = op.getOut().getType();

  // Compute the operation statistics for the currently visited operation.
  total_ops_ = 0;

  getOperation()->walk([&](Operation *op) {
    auto op_with_dialect_name = op->getName().getStringRef();
    auto op_name = op->getName().stripDialect();
    auto dialect_name = op->getDialect()->getNamespace();

    if (op->getNumResults() > 0 &&
        isa<ShapedType>(op->getResult(0).getType())) {

  auto window_strides__ = window_strides ? _fbb.CreateVector<int64_t>(*window_strides) : 0;
  auto padding__ = padding ? _fbb.CreateVector<int64_t>(*padding) : 0;
  auto lhs_dilation__ = lhs_dilation ? _fbb.CreateVector<int64_t>(*lhs_dilation) : 0;
  auto rhs_dilation__ = rhs_dilation ? _fbb.CreateVector<int64_t>(*rhs_dilation) : 0;

    llvm::SmallVector<mlir::NamedAttribute, 4> attrs;
    const auto& keys = m.Keys();
    for (size_t i = 0; i < keys.size(); ++i) {
      const auto key = keys[i].AsKey();
      const auto& value = m[key];
      switch (value.GetType()) {
        case flexbuffers::FBT_INT: {
          auto attr = value.AsInt64();
          auto named_attr = builder->getNamedAttr(

        "colorMode": "value",
        "graphMode": "none",
        "justifyMode": "auto",
        "orientation": "auto",
        "reduceOptions": {
          "calcs": [
            "mean"
          ],
          "fields": "",
          "values": false
        },
        "showPercentChange": false,
        "text": {},
        "textMode": "auto",
        "wideLayout": true
      },
      "pluginVersion": "10.4.0",

    auto elem_type = filter_type.getElementType();
    auto bias_dim = static_cast<const ConcreteType *>(this)->getBiasDim(
        filter_type.getShape());
    auto bias_type =
        tensorflow::GetTypeFromTFTensorShape({bias_dim}, elem_type);
    auto bias_attr = rewriter.getZeroAttr(bias_type);
    auto bias =

  Output arg1 = ops::_Arg(s.WithOpName("arg1"), DT_BOOL, 1);
  NameAttrList f;
  f.set_name("f1");
  auto if_op = ops::If(s.WithOpName("if"), arg1,
                       std::initializer_list<Input>{arg0, arg1},
                       {DT_BOOL, DT_RESOURCE}, f, f);
  auto ret0 = ops::_Retval(s.WithOpName("ret0"), if_op.output[0], 0);
  auto ret1 = ops::_Retval(s.WithOpName("ret1"), if_op.output[1], 1);
  NameAttrList cond_fn, body_fn;

  Type ref_qtype = nullptr;
  for (auto *var_handle_user : var_handle_op.getResult().getUsers()) {
    auto read_variable_op = dyn_cast_or_null<ReadVariableOp>(var_handle_user);
    if (!read_variable_op) continue;
    for (auto *read_variable_user : read_variable_op.getResult().getUsers()) {
      auto q_op = dyn_cast_or_null<QuantizeOp>(read_variable_user);
      if (!q_op || ref_qtype) continue;

    return false;

  if (auto arith_const_op = dyn_cast_or_null<arith::ConstantOp>(op)) {
    // arith ConstOp path.
    auto type =
        mlir::cast<ShapedType>(arith_const_op.getType()).getElementType();
    if (!type.isInteger(32) && !type.isInteger(64)) return false;
  } else if (auto const_op = dyn_cast_or_null<TFL::ConstOp>(op)) {
    // ConstOp path.