// neither.
mlir::RankedTensorType GetBufferType(mlir::Type ty) {
  auto ranked_ty = mlir::dyn_cast_or_null<mlir::RankedTensorType>(ty);
  if (!ranked_ty) return {};

  int64_t rank = ranked_ty.getRank();
  llvm::SmallVector<int64_t, 4> dims = llvm::to_vector<4>(ranked_ty.getShape());
  auto encoding = mlir::dyn_cast_or_null<mlir::mhlo::TypeExtensionsAttr>(
      ranked_ty.getEncoding());

  if (ranked_ty.hasStaticShape()) return true;

  auto encoding =
      mlir::dyn_cast_or_null<TypeExtensionsAttr>(ranked_ty.getEncoding());
  if (!encoding) return false;

  for (int i = 0; i < ranked_ty.getRank(); ++i) {
    if (ranked_ty.isDynamicDim(i) &&
        encoding.getBounds()[i] == ShapedType::kDynamic) {
      return false;
    }
  }
  return true;
}

bool HasSymbolRefAttr(Operation* op) {

  }

  // Allow dynamic width and height dimensions only.
  auto result_ty = mlir::cast<TensorType>(op.getResult().getType());
  if (!result_ty.hasRank() || result_ty.getRank() != 4 ||
      result_ty.isDynamicDim(0) || result_ty.isDynamicDim(3)) {
    return rewriter.notifyMatchFailure(
        op, "only dynamic width and height dimensions are allowed");
  }

    // verify shardings that actually break a tensor apart.
    return mlir::success();
  }
  if (RankedTensorType ranked_type = mlir::dyn_cast<RankedTensorType>(type)) {
    const int64_t tensor_rank = ranked_type.getRank();
    int tile_assignment_rank = sharding->tile_assignment_dimensions_size();

    // When a tensor is partial or subgroup tiled, its tile assignment will

    if (bias_op != nullptr) {
      Type bias_type = bias_op->getResult(0).getType();
      if (bias_type != builder_.getNoneType()) {
        const int bias_rank = mlir::dyn_cast<ShapedType>(bias_type).getRank();
        adjusted_quant_dim = bias_rank > 1 ? bias_rank - 1 : 0;
      }
    }
  }

  for (const int non_bias_operand_index : non_bias_operand_indices) {
    const QuantState& non_bias_state =

                        effective_maxs[0], builder.getUnknownLoc());
    }
  } else if (min.size() == max.size()) {
    auto shape = dyn_cast<ShapedType>(input_type);
    if (!shape || shape.getRank() <= quant_dim ||
        static_cast<int64_t>(min.size()) != shape.getDimSize(quant_dim)) {
      return {};
    }
    // The quantization dim is set to the last dimension.

    TensorType new_shape = RankedTensorType::get(
        {weight_shape[0], weight_shape[1], in_channels, multiplier},
        weight_type.getElementType());

    int cur_rank = weight_type.getRank();

    // Inserts a reshape op.
    auto shape_spec_type =
        RankedTensorType::get({cur_rank}, rewriter.getIntegerType(64));
    auto new_shape_const_attr =

    const int quantization_dimension = GetFilterQuantizationDimension(
        op.getDotDimensionNumbers(),
        mlir::cast<TensorType>(filter_value_attr.getType()).getRank());
    const UniformQuantizedPerAxisType filter_uniform_quantized_type =
        CreateI8F32UniformQuantizedPerAxisType(
            filter_constant_op.getLoc(), *rewriter.getContext(),

    if (matchPattern(op_state.operands[1], m_Constant(&shape_attr))) {
      auto shape_ty =
          op_state.operands[1].getType().dyn_cast<RankedTensorType>();
      if (shape_ty != nullptr && shape_ty.hasRank() && shape_ty.getRank() > 1) {
        llvm::SmallVector<mlir::Attribute, 4> shape;
        int32_t dim_size = 0;
        for (const auto& dim :
             llvm::enumerate(shape_attr.getValues<llvm::APInt>())) {

            throw new IllegalArgumentException("Supplied relative URI escapes baseUrl");
        }
        GetTask getTask = new GetTask(source);
        getTask.setDataPath(target);
        try {
            transporter.get(getTask);
            return true;
        } catch (Exception e) {
            if (Transporter.ERROR_NOT_FOUND != transporter.classify(e)) {