for (auto msubgraph : *mutable_subgraphs) {
    auto operators = msubgraph->mutable_operators();
    for (auto op : *operators) {
      auto opcode_idx = op->opcode_index();
      auto opcodes = mutable_model->operator_codes();
      auto opcode = (*opcodes)[opcode_idx]->builtin_code();
      if (opcode == tflite::BuiltinOperator_CUSTOM) {
        std::vector<int32_t> inputs(op->inputs()->begin(), op->inputs()->end());

  ASSERT_THAT(GetBuiltinCode(model_.operator_codes[op1->opcode_index].get()),
              Eq(BuiltinOperator_QUANTIZE));
  ASSERT_THAT(GetBuiltinCode(model_.operator_codes[op2->opcode_index].get()),
              Eq(BuiltinOperator_QUANTIZE));
  ASSERT_THAT(GetBuiltinCode(model_.operator_codes[op3->opcode_index].get()),
              Eq(BuiltinOperator_PACK));

      const auto op = subgraph->operators()->Get(op_idx);
      for (size_t i = 0; i < op->outputs()->size(); ++i) {
        if (op->outputs()->Get(i) == tensor_idx) {
          const uint32_t op_code_idx = op->opcode_index();
          *op_code = GetBuiltinCode(model->operator_codes()->Get(op_code_idx));
          return true;
        }
      }
    }
    return false;
  }
};

  for (auto& sub_graph : model->subgraphs) {
    for (auto& op : sub_graph->operators) {
      if (tflite::GetBuiltinCode(
              model->operator_codes[op->opcode_index].get()) ==
          tflite::BuiltinOperator_FULLY_CONNECTED) {
        // inject min/max to the input and output tensors
        auto& input_tensor = sub_graph->tensors[op->inputs[0]];

// Returns the FlatBuffer offset for the operator on success; emits error and
// returns std::nullopt on failure.
std::optional<flatbuffers::Offset<tflite::Operator>> CreateFlatBufferOperator(
    Operation *mlir_op, uint32_t opcode_index,
    const std::vector<int32_t> &operands, const std::vector<int32_t> &results,
    const std::vector<int32_t> &intermediates,
    flatbuffers::FlatBufferBuilder *fbb);

# CHECK:       builtin_options_type: Conv2DOptions,
# CHECK:       builtin_options: {
# CHECK:         stride_w: 1,
# CHECK:         stride_h: 1
# CHECK:       }
# CHECK:     }, {
# CHECK:       opcode_index: 1,
# CHECK:       inputs: [ 4, 1 ],
# CHECK:       outputs: [ 5 ]
# CHECK:     } ],
# CHECK:     name: "main"
# CHECK:   } ],
# CHECK:   description: "MLIR Converted.",
# CHECK:   buffers: [ {

# CHECK:       builtin_options_type: Conv2DOptions,
# CHECK:       builtin_options: {
# CHECK:         stride_w: 1,
# CHECK:         stride_h: 1
# CHECK:       }
# CHECK:     }, {
# CHECK:       opcode_index: 1,
# CHECK:       inputs: [ 4, 1 ],
# CHECK:       outputs: [ 5 ]
# CHECK:     } ],
# CHECK:     name: "main"
# CHECK:   } ],
# CHECK:   description: "MLIR Converted.",
# CHECK:   buffers: [ {

    const std::unique_ptr<tflite::FlatBufferModel>& model_ptr) {
  llvm::SmallVector<Value, 4> operands;
  llvm::SmallVector<mlir::Type, 2> outputTypes;

  const tflite::OperatorCodeT& op_code = *op_codes.at(op.opcode_index);

  const std::string op_name = GetMlirOpName(op, op_code);

  OperationState op_state(loc, op_name);

  for (auto input_num : op.inputs) {
    if (input_num == -1) {

struct OperatorBuilder {
  typedef Operator Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_opcode_index(uint32_t opcode_index) {
    fbb_.AddElement<uint32_t>(Operator::VT_OPCODE_INDEX, opcode_index, 0);
  }
  void add_inputs(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> inputs) {
    fbb_.AddOffset(Operator::VT_INPUTS, inputs);
  }