// 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
    }

      name: "function"
      input_arg {
        name: "inputs"
        type: DT_FLOAT
      }
      input_arg {
        name: "statefulpartitionedcall_args_1"
        type: DT_RESOURCE
      }
      output_arg {
        name: "identity"
        type: DT_FLOAT
      }
      is_stateful: true
    }
    node_def {
      name: "Identity"
      op: "Identity"
      input: "inputs"
      attr {

      name: "function"
      input_arg {
        name: "inputs"
        type: DT_FLOAT
      }
      input_arg {
        name: "statefulpartitionedcall_args_1"
        type: DT_RESOURCE
      }
      output_arg {
        name: "identity"
        type: DT_FLOAT
      }
      is_stateful: true
    }
    node_def {
      name: "Identity"
      op: "Identity"
      input: "inputs"
      attr {

op {
  name: "Foo"
  input_arg {
    name: "images"
    description: "Images to process."
  }
  input_arg {
    name: "dim"
    description: "Description for dim."
    type: DT_FLOAT
  }
  output_arg {
    name: "output"
    description: "Description for output."
    type: DT_FLOAT
  }
  attr {
    name: "T"
    type: "type"
    description: "Type for images"
    allowed_values {
      list {

  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);