#include "pch.h"

<% functionCount.times { %>
int ${functionName}_${it+1} () {
  printf("Hello world!");
  return 0;
}

#include <stdio.h>

<% functionCount.times { %>
int ${functionName}_${it+1} () {
  printf("Hello world!");
  return 0;
}

      absl::Nonnull<MLIRContext*> ctx,
      absl::Nonnull<const tensorflow::quantization::PyFunctionLibrary*>
          py_function_lib,
      absl::string_view src_saved_model_path,
      absl::flat_hash_map<FunctionName, FunctionAlias> function_aliases,
      std::unordered_set<std::string> tags,
      absl::flat_hash_map<std::string, tensorflow::SignatureDef>
          signature_def_map,
      std::vector<std::string> signature_keys);

    std::vector<std::string> signature_keys,
    std::unordered_set<std::string> tags,
    absl::flat_hash_map<std::string, SignatureDef> signature_def_map,
    absl::flat_hash_map<FunctionName, FunctionAlias> function_aliases)
    : ctx_(ctx) {
  // Initialize the three sub-components.
  sub_components_[0] = std::make_unique<PreCalibrationComponent>(ctx_);

// example, it is easy to confuse function name -> alias mapping with alias ->
// function name mapping when both are just represented as `std::string`.
using FunctionAlias = std::string;
using FunctionName = std::string;

}  // namespace mlir::quant::stablehlo

  const std::vector<OpArgumentView> &AllArguments() const;

  int NumInputs() const;
  int NumOutputs() const;
  ArgView OnlyInput() const;
  ArgView OnlyOutput() const;

  string FunctionName() const;
  string VariableName() const;
  string OpNameString() const;
  string Summary() const;
  std::vector<string> Description() const;
  bool IsListOp() const;

 private:
  OpSpec op_;

void OpCommentRenderer::Render() {
  if (context_.mode == RendererContext::kHeader) {
    // Add a short 1-line comment to the header files.
    CommentLine(op_.Summary());
    return;
  }

  CommentLine("Op: $0()", op_.FunctionName());
  CommentLine("Summary: $0", op_.Summary());
  CommentLine("");
  CommentLine("Description:");
  for (const auto& line : op_.Description()) {
    CommentLine("  $0", line);
  }
}

}  // namespace cpp

                   std::make_move_iterator(args_with_default_val.begin()),
                   std::make_move_iterator(args_with_default_val.end()));
  return absl::Substitute("$0 $1($2)", "Status", op_.FunctionName(),
                          absl::StrJoin(arguments, ", "));
}

OpRenderer::OpRenderer(RendererContext context, OpView op)
    : Renderer(context), op_(op), comment_(context, op) {}

void OpRenderer::Render() {

  return input_args_.front();
}

ArgView OpView::OnlyOutput() const {
  CHECK_EQ(output_args_.size(), 1);  // Crash OK
  return output_args_.front();
}

string OpView::FunctionName() const { return op_.name(); }

string OpView::OpNameString() const { return Quoted(op_.name()); }

string OpView::VariableName() const { return "op_ptr"; }

std::vector<string> OpView::Description() const {

      std::vector<std::string> signature_keys,
      std::unordered_set<std::string> tags,
      absl::flat_hash_map<std::string, tensorflow::SignatureDef>
          signature_def_map,
      absl::flat_hash_map<FunctionName, FunctionAlias> function_aliases);

  // Runs the static-range post-training quantization (PTQ) on `module_op`.
  absl::StatusOr<ModuleOp> Run(
      ModuleOp module_op,