// attributes.
  for (const tensorflow::OpDef::ArgDef& output_arg : op_def_->output_arg()) {
    int original_size = state_->types.size();
    if (!output_arg.number_attr().empty()) {
      // Same type repeated "repeats" times.
      Attribute repeats_attr = attrs_[output_arg.number_attr()];
      if (!repeats_attr)
        return InvalidArgument("Missing attribute '", output_arg.number_attr(),

void OpImplementationRenderer::RenderExecutionListOp() {
  ArgView output_arg = op_.OnlyOutput();
  Statement("int num_retvals = $0.size()", output_arg.VariableName());
  Statement("return " + Call(op_.VariableName(), "Execute",
                             {output_arg.VariableName(), "&num_retvals"}));
}

void OpImplementationRenderer::RenderExecutionSingleOutput() {
  ArgView output_arg = op_.OnlyOutput();
  Statement("int num_retvals = 1");

    "'raw_outputs/class_predictions' type: DT_FLOAT } input_arg: { name: "
    "'anchors' type: DT_FLOAT } output_arg: { name: "
    "'TFLite_Detection_PostProcess' type: DT_FLOAT } output_arg: { name: "
    "'TFLite_Detection_PostProcess:1' type: DT_FLOAT } output_arg: { name: "
    "'TFLite_Detection_PostProcess:2' type: DT_FLOAT } output_arg: { name: "
    "'TFLite_Detection_PostProcess:3' type: DT_FLOAT } attr : { name: "

node {
  name: "_tf.foo"
  op: "foo"
  input: "Constant"
}
library {
  function {
    signature {
      name: "foo"
      input_arg {
        name: "arg"
        type: DT_INT32
      }
      output_arg {
        name: "return_value"
        type: DT_INT32
      }
    }
    ret {
      key: "return_value"
      value: "arg"
    }
  }
}
versions {
  producer: 62
  min_consumer: 12
}

    value {
      s: "cluster"
    }
  }
}
library {
  function {
    signature {
      name: "test_func_name"
      input_arg {
        name: "a_0"
        type: DT_INT32
      }
      output_arg {
        name: "a"
        type: DT_INT32
      }
    }
    ret {
      key: "a"
      value: "a_0"
    }
    attr {
      key: "_disable_call_shape_inference"
      value {
        b: true

    signature {
      name: "test_func_name"
      input_arg {
        name: "a_0"
        type: DT_RESOURCE
      }
      input_arg {
        name: "a_1"
        type: DT_RESOURCE
      }
      output_arg {
        name: "a"
        type: DT_RESOURCE
      }
    }
    resource_arg_unique_id {
      key: 0
      value: 0
    }
    resource_arg_unique_id {
      key: 1
      value: 0
    }

  EXPECT_EQ(f1_rewritten->signature().input_arg(1).type(), DT_RESOURCE);
  ASSERT_EQ(f1_rewritten->signature().output_arg_size(), 1);
  EXPECT_EQ(f1_rewritten->signature().output_arg(0).type(), DT_BOOL);

  // Check node "if" input and output edges.
  auto node_name_index = g->BuildNodeNameIndex();
  const Node *if_node = node_name_index.at("if");
  ASSERT_NE(if_node, nullptr);

      "    signature {"
      "      name: 'AddVariablesFunction'"
      "      input_arg {"
      "        name: 'var'"
      "        type: DT_RESOURCE"
      "      }"
      "      output_arg {"
      "        name: 'sum'"
      "        type: DT_FLOAT"
      "      }"
      "    }"
      "    node_def {"
      "      name: 'read0'"
      "      op: 'ReadVariableOp'"
      "      input: 'var'"

        // Add derived "result_segment_sizes" attr to the created operation.
        // TODO(b/146937733): Don't use <void> here.
        set_segment_sizes_attr(output_ranges, op_def->output_arg(),
                               mlir::OpTrait::AttrSizedResultSegments<
                                   void>::getResultSegmentSizeAttr());
      }
    }

    return success();
  }

 private:

        auto cf_consider_fn = [disable_constant_folding](const Node* n) {
          if (disable_constant_folding) return false;
          for (const auto& output_arg : n->op_def().output_arg()) {
            if (output_arg.type() == DT_VARIANT) {
              return false;
            }
          }
          return true;
        };
        GraphOptimizer::Options graph_optimizer_options;