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
      }
    }
    # Drop the control dependency on arg for the node "test"
    # CHECK-LABEL: func private @foo

      name: "cond_true"
      input_arg {
        name: "cond_true"
        type: DT_FLOAT
      }
      input_arg {
        name: "cond_true1"
        type: DT_FLOAT
      }
      output_arg {
        name: "cond_true2"
        type: DT_FLOAT
      }
    }
    node_def {
      name: "tf.Add"
      op: "Add"
      input: "cond_true"
      input: "cond_true1"
      attr {

    }
  }
  experimental_debug_info {
  }
}
library {
  function {
    signature {
      name: "foo"
      input_arg {
        name: "foo"
        type: DT_FLOAT
      }
      output_arg {
        name: "foo1"
        type: DT_FLOAT
      }
    }
    node_def {
      name: "Exp"
      op: "Exp"
      input: "foo"
      attr {
        key: "T"
        value {

      i: 16
    }
  }
  attr: {
    key: "shared_name"
    value: {
      s: ""
    }
  }
}
library {
  function {
    signature {
      name: "create_resource"
      output_arg {
        name: "handle"
        type: DT_RESOURCE
      }
    }
    node_def: {
      name: "hash_table_node"
      op: "HashTableV2"
      attr: {
        key: "key_dtype"
        value: {

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
}

      }
    } else if (!arg_def.type_list_attr().empty()) {
      inferred_attrs.insert(arg_def.type_list_attr());
    }
  }
  for (const OpDef::ArgDef& arg_def : op_def.output_arg()) {
    ArgSpec arg = ArgSpec::CreateOutput(arg_def, output_args_.size());
    output_args_.push_back(arg);
  }
  // Parse the attributes.
  for (const OpDef::AttrDef& attr_def : op_def.attr()) {
    AttrSpec attr = AttrSpec::Create(attr_def);

    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

      }
    }
  }
  attr {
    key: "f"
    value {
      func {
        name: "foo"
      }
    }
  }
}
library {
  function {
    signature {
      name: "foo"
      output_arg {
        name: "constant"
        type: DT_FLOAT
      }
    }
    node_def {
      name: "X"
      op: "Const"
      attr {
        key: "dtype"
        value {
          type: DT_FLOAT

  }
  experimental_debug_info {
  }
}
library {
  function {
    signature {
      name: "identity_function"
      input_arg {
        name: "identity_input"
        type: DT_INT32
      }
      output_arg {
        name: "identity_output"
        type: DT_INT32
      }
    }
    ret {
      key: "identity_output"
      value: "identity_input"
    }
    attr {
      key: "_input_shapes"
      value {

node {
  name: "output"
  op: "BannaPotatoSaladWithColeslaw"
  input: "input0"
  input: "input1"
  attr {
    key: "T"
    value {
      type: DT_INT32
    }