bool HasStaticShapeAtDims(Value value, ArrayRef<int> dims);

// Whether `value` has known rank of `rank`. Returns false when it is not a
// `ShapedType` or its rank is unknown.
inline bool HasRankOf(Value value, const int64_t rank) {
  auto shaped_type = mlir::dyn_cast_or_null<ShapedType>(value.getType());
  return shaped_type && shaped_type.hasRank() && shaped_type.getRank() == rank;
}

Type TypeMeet(Type lhs, Type rhs) {
  DCOMMENT("RefineTypeWith : " << lhs << " : " << rhs);
  if (lhs == rhs) return lhs;

  auto rhs_shape_type = mlir::dyn_cast<ShapedType>(rhs);
  if (!rhs_shape_type) return lhs;
  auto lhs_shape_type = mlir::cast<ShapedType>(lhs);
  if (lhs_shape_type.hasRank() && rhs_shape_type.hasRank() &&
      lhs_shape_type.getRank() != rhs_shape_type.getRank()) {

      std::string asset_filename = asset.getFilename().str();
      std::string filename =
          tensorflow::io::JoinPath(saved_model_dir, asset_filename);
      ShapedType shaped_type =
          RankedTensorType::get({1}, TF::StringType::get(builder.getContext()));
      auto const_op = builder.create<TF::ConstOp>(
          asset.getLoc(),

  for (func::FuncOp func : module.getOps<func::FuncOp>()) {
    llvm::SmallVector<arith::ConstantOp, 4> constant_ops(
        func.getOps<arith::ConstantOp>());
    for (auto op : constant_ops) {
      ShapedType shaped_type =
          RankedTensorType::get({1}, StringType::get(context));

      DenseStringElementsAttr attr;
      if (!matchPattern(op.getOperation(), m_Constant(&attr))) {
        continue;
      }

    quant::AdjacentOperations *new_items, bool *changed) {
  // Use the final state to set all the operands' parameters.
  for (int i = 0, e = op->getNumOperands(); i != e; ++i) {
    auto ele = op->getOperand(i).getType().cast<ShapedType>().getElementType();
    if (ele.isa<FloatType>() && SetOperandParams(op, i, params)) {
      *changed |= true;
      new_items->push_back(op->getOperand(i).getDefiningOp());
    }
  }

  return true;
}

// Appends function arguments with `num_resources` number of arguments of
// requested type.
void AppendFunctionArguments(func::FuncOp func, int num_resources,
                             ShapedType chaining_data_type) {
  for (int i = 0; i < num_resources; ++i) {
    func.getRegion().addArgument(chaining_data_type, func.getLoc());
  }

  FunctionType ftype =

      auto shape = llvm::to_vector<4>(inputType.getShape());
      llvm::SmallVector<int64_t, 4> bounds(shape.begin(), shape.end());
      // Mark the dim as dynamic dim.
      shape[0] = ShapedType::kDynamic;
      auto extensions =
          mhlo::TypeExtensionsAttr::get(func->getContext(), bounds);
      auto resultType =
          RankedTensorType::get(shape, inputType.getElementType(), extensions);

    auto next_op = *transpose_op.getResult().getUsers().begin();
    if (dyn_cast_or_null<quantfork::QuantizeCastOp>(next_op)) return failure();

    auto input_type = mlir::cast<ShapedType>(transpose_op.getInput().getType());
    auto perm_type = mlir::cast<ShapedType>(transpose_op.getPerm().getType());
    if (input_type.hasStaticShape() && perm_type.hasStaticShape()) {
      if (perm_type.getNumElements() != input_type.getRank()) {

  auto result_tuple_ty =
      mlir::dyn_cast_or_null<TupleType>(func.getFunctionType().getResult(0));
  if (!result_tuple_ty) return;
  if (result_tuple_ty.size() != 1) return;
  auto result_ty = mlir::dyn_cast<ShapedType>(result_tuple_ty.getType(0));

  func.eraseBody();
  func.addEntryBlock();
  ImplicitLocOpBuilder builder(func.getLoc(), func.getBody());
  llvm::SmallVector<int32_t> result_shape_i32;

        auto original_result_type = user_op->getResult(0).getType();
        auto new_user_op_type = CloneTypeWithNewElementType(
            original_result_type,
            mlir::cast<ShapedType>(op_before_dequantize.getType())
                .getElementType());
        createNewDequantizeOp(rewriter, op, user_op, user_idx,
                              new_user_op_type);
      } else {