for (auto it = func.begin(); it != func.end(); ++it) ++num_ops;
  return num_ops;
}

std::vector<Value> ResultsAsVector(Operation* op) {
  std::vector<Value> vec;
  vec.reserve(op->getNumResults());
  for (auto res : op->getResults()) vec.push_back(res);
  return vec;
}

void SetBasicBlockAttributes(OpBuilder& builder, Operation* op) {
  op->setAttr(kDevice, builder.getStringAttr(""));

  {
    llvm::SmallVector<DictionaryAttr, 8> tmp;
    func.getAllResultAttrs(tmp);

    for (const auto& res : tmp) {
      result_attrs.push_back(res.getValue().vec());
    }
  }

  mlir::Builder builder(func.getOperation());

  for (OpOperand& operand : fetch.getOperation()->getOpOperands()) {
    if (mlir::isa<tf_executor::ControlType>(operand.get().getType())) break;

        mlir::cast<quant::UniformQuantizedPerAxisType>(filter_state.params);
    std::vector<double> new_bias_scales = bias_quantized_type.getScales().vec();
    std::vector<double> new_filter_scales =
        filter_quantized_type.getScales().vec();

    bool needs_adjustment = false;
    for (int i = 0; i < bias_quantized_type.getScales().size(); ++i) {

  return FlatBufferModel::BuildFromFile(model_path.c_str());
}

template <typename T>
std::vector<T> GetAsVector(const flatbuffers::Vector<T>* vec) {
  return std::vector<T>(vec->begin(), vec->end());
}

void VerifyQuantizationScale(
    const QuantizationParameters& float_quant_params,
    const QuantizationParametersT& quantized_quant_params, const int bit_num,

  auto edge_padding_low =
      builder_.CreateVector(pad_op.getEdgePaddingLow().vec());
  auto edge_padding_high =
      builder_.CreateVector(pad_op.getEdgePaddingHigh().vec());
  auto interior_padding =
      builder_.CreateVector(pad_op.getInteriorPadding().vec());

  auto pad_option = tflite::CreateStablehloPadOptions(

                            bool is_kernel = false) -> mlir::Value {
      std::vector<int64_t> tensor_shape =
          mlir::cast<ShapedType>(tensor.getType()).getShape().vec();

      // Calculate offsets based on depth_idx, channel_idx and tensor_shape
      std::vector<int64_t> start_indices(tensor_shape.size(), 0);
      std::vector<int64_t> limit_indices = tensor_shape;

// `tensor<3x2xi32>`.
static RankedTensorType SubstituteRankedTensorTypeDimSize(
    RankedTensorType input_type, int64_t dim, int64_t dim_size) {
  auto shape = input_type.getShape().vec();
  shape[dim] = dim_size;
  return tensorflow::GetTypeFromTFTensorShape(shape,
                                              input_type.getElementType());
}