TensorFlow.NET/src/TensorFlowNET.Core/Protobuf/SavedObjectGraph.cs

// <auto-generated>
//     Generated by the protocol buffer compiler.  DO NOT EDIT!
//     source: tensorflow/core/protobuf/saved_object_graph.proto
// </auto-generated>
#pragma warning disable 1591, 0612, 3021
#region Designer generated code

using pb = global::Google.Protobuf;
using pbc = global::Google.Protobuf.Collections;
using pbr = global::Google.Protobuf.Reflection;
using scg = global::System.Collections.Generic;
namespace Tensorflow {

  /// <summary>Holder for reflection information generated from tensorflow/core/protobuf/saved_object_graph.proto</summary>
  public static partial class SavedObjectGraphReflection {

    #region Descriptor
    /// <summary>File descriptor for tensorflow/core/protobuf/saved_object_graph.proto</summary>
    public static pbr::FileDescriptor Descriptor {
      get { return descriptor; }
    }
    private static pbr::FileDescriptor descriptor;

    static SavedObjectGraphReflection() {
      byte[] descriptorData = global::System.Convert.FromBase64String(
          string.Concat(
            "CjF0ZW5zb3JmbG93L2NvcmUvcHJvdG9idWYvc2F2ZWRfb2JqZWN0X2dyYXBo",
            "LnByb3RvEgp0ZW5zb3JmbG93Gix0ZW5zb3JmbG93L2NvcmUvZnJhbWV3b3Jr",
            "L3RlbnNvcl9zaGFwZS5wcm90bxoldGVuc29yZmxvdy9jb3JlL2ZyYW1ld29y",
            "ay90eXBlcy5wcm90bxoodGVuc29yZmxvdy9jb3JlL2ZyYW1ld29yay92YXJp",
            "YWJsZS5wcm90bxoodGVuc29yZmxvdy9jb3JlL2ZyYW1ld29yay92ZXJzaW9u",
            "cy5wcm90bxoldGVuc29yZmxvdy9jb3JlL3Byb3RvYnVmL3N0cnVjdC5wcm90",
            "bxo1dGVuc29yZmxvdy9jb3JlL3Byb3RvYnVmL3RyYWNrYWJsZV9vYmplY3Rf",
            "Z3JhcGgucHJvdG8i6AEKEFNhdmVkT2JqZWN0R3JhcGgSJgoFbm9kZXMYASAD",
            "KAsyFy50ZW5zb3JmbG93LlNhdmVkT2JqZWN0Ek8KEmNvbmNyZXRlX2Z1bmN0",
            "aW9ucxgCIAMoCzIzLnRlbnNvcmZsb3cuU2F2ZWRPYmplY3RHcmFwaC5Db25j",
            "cmV0ZUZ1bmN0aW9uc0VudHJ5GlsKFkNvbmNyZXRlRnVuY3Rpb25zRW50cnkS",
            "CwoDa2V5GAEgASgJEjAKBXZhbHVlGAIgASgLMiEudGVuc29yZmxvdy5TYXZl",
            "ZENvbmNyZXRlRnVuY3Rpb246AjgBIpAGCgtTYXZlZE9iamVjdBJSCghjaGls",
            "ZHJlbhgBIAMoCzJALnRlbnNvcmZsb3cuVHJhY2thYmxlT2JqZWN0R3JhcGgu",
            "VHJhY2thYmxlT2JqZWN0Lk9iamVjdFJlZmVyZW5jZRJeCg5zbG90X3Zhcmlh",
            "YmxlcxgDIAMoCzJGLnRlbnNvcmZsb3cuVHJhY2thYmxlT2JqZWN0R3JhcGgu",
            "VHJhY2thYmxlT2JqZWN0LlNsb3RWYXJpYWJsZVJlZmVyZW5jZRIyCgt1c2Vy",
            "X29iamVjdBgEIAEoCzIbLnRlbnNvcmZsb3cuU2F2ZWRVc2VyT2JqZWN0SAAS",
            "JwoFYXNzZXQYBSABKAsyFi50ZW5zb3JmbG93LlNhdmVkQXNzZXRIABItCghm",
            "dW5jdGlvbhgGIAEoCzIZLnRlbnNvcmZsb3cuU2F2ZWRGdW5jdGlvbkgAEi0K",
            "CHZhcmlhYmxlGAcgASgLMhkudGVuc29yZmxvdy5TYXZlZFZhcmlhYmxlSAAS",
            "RwoWYmFyZV9jb25jcmV0ZV9mdW5jdGlvbhgIIAEoCzIlLnRlbnNvcmZsb3cu",
            "U2F2ZWRCYXJlQ29uY3JldGVGdW5jdGlvbkgAEi0KCGNvbnN0YW50GAkgASgL",
            "MhkudGVuc29yZmxvdy5TYXZlZENvbnN0YW50SAASLQoIcmVzb3VyY2UYCiAB",
            "KAsyGS50ZW5zb3JmbG93LlNhdmVkUmVzb3VyY2VIABI1Cg9jYXB0dXJlZF90",
            "ZW5zb3IYDCABKAsyGi50ZW5zb3JmbG93LkNhcHR1cmVkVGVuc29ySAASRgoQ",
            "c2F2ZWFibGVfb2JqZWN0cxgLIAMoCzIsLnRlbnNvcmZsb3cuU2F2ZWRPYmpl",
            "Y3QuU2F2ZWFibGVPYmplY3RzRW50cnkaUgoUU2F2ZWFibGVPYmplY3RzRW50",
            "cnkSCwoDa2V5GAEgASgJEikKBXZhbHVlGAIgASgLMhoudGVuc29yZmxvdy5T",
            "YXZlYWJsZU9iamVjdDoCOAFCBgoEa2luZEoECAIQA1IKYXR0cmlidXRlcyJk",
            "Cg9TYXZlZFVzZXJPYmplY3QSEgoKaWRlbnRpZmllchgBIAEoCRInCgd2ZXJz",
            "aW9uGAIgASgLMhYudGVuc29yZmxvdy5WZXJzaW9uRGVmEhQKCG1ldGFkYXRh",
            "GAMgASgJQgIYASIqCgpTYXZlZEFzc2V0EhwKFGFzc2V0X2ZpbGVfZGVmX2lu",
            "ZGV4GAEgASgFIlwKDVNhdmVkRnVuY3Rpb24SGgoSY29uY3JldGVfZnVuY3Rp",
            "b25zGAEgAygJEi8KDWZ1bmN0aW9uX3NwZWMYAiABKAsyGC50ZW5zb3JmbG93",
            "LkZ1bmN0aW9uU3BlYyI5Cg5DYXB0dXJlZFRlbnNvchIMCgRuYW1lGAEgASgJ",
            "EhkKEWNvbmNyZXRlX2Z1bmN0aW9uGAIgASgJIqgBChVTYXZlZENvbmNyZXRl",
            "RnVuY3Rpb24SFAoMYm91bmRfaW5wdXRzGAIgAygFEkIKHWNhbm9uaWNhbGl6",
            "ZWRfaW5wdXRfc2lnbmF0dXJlGAMgASgLMhsudGVuc29yZmxvdy5TdHJ1Y3R1",
            "cmVkVmFsdWUSNQoQb3V0cHV0X3NpZ25hdHVyZRgEIAEoCzIbLnRlbnNvcmZs",
            "b3cuU3RydWN0dXJlZFZhbHVlIq0BChlTYXZlZEJhcmVDb25jcmV0ZUZ1bmN0",
            "aW9uEh4KFmNvbmNyZXRlX2Z1bmN0aW9uX25hbWUYASABKAkSGQoRYXJndW1l",
            "bnRfa2V5d29yZHMYAiADKAkSJAocYWxsb3dlZF9wb3NpdGlvbmFsX2FyZ3Vt",
            "ZW50cxgDIAEoAxIvCg1mdW5jdGlvbl9zcGVjGAQgASgLMhgudGVuc29yZmxv",
            "dy5GdW5jdGlvblNwZWMiIgoNU2F2ZWRDb25zdGFudBIRCglvcGVyYXRpb24Y",
            "ASABKAki1wIKDVNhdmVkVmFyaWFibGUSIwoFZHR5cGUYASABKA4yFC50ZW5z",
            "b3JmbG93LkRhdGFUeXBlEisKBXNoYXBlGAIgASgLMhwudGVuc29yZmxvdy5U",
            "ZW5zb3JTaGFwZVByb3RvEhEKCXRyYWluYWJsZRgDIAEoCBI8Cg9zeW5jaHJv",
            "bml6YXRpb24YBCABKA4yIy50ZW5zb3JmbG93LlZhcmlhYmxlU3luY2hyb25p",
            "emF0aW9uEjQKC2FnZ3JlZ2F0aW9uGAUgASgOMh8udGVuc29yZmxvdy5WYXJp",
            "YWJsZUFnZ3JlZ2F0aW9uEgwKBG5hbWUYBiABKAkSDgoGZGV2aWNlGAcgASgJ",
            "Ek8KLGV4cGVyaW1lbnRhbF9kaXN0cmlidXRlZF92YXJpYWJsZV9jb21wb25l",
            "bnRzGAggAygLMhkudGVuc29yZmxvdy5TYXZlZFZhcmlhYmxlIvsBCgxGdW5j",
            "dGlvblNwZWMSMAoLZnVsbGFyZ3NwZWMYASABKAsyGy50ZW5zb3JmbG93LlN0",
            "cnVjdHVyZWRWYWx1ZRIRCglpc19tZXRob2QYAiABKAgSNAoPaW5wdXRfc2ln",
            "bmF0dXJlGAUgASgLMhsudGVuc29yZmxvdy5TdHJ1Y3R1cmVkVmFsdWUSOAoL",
            "aml0X2NvbXBpbGUYBiABKA4yIy50ZW5zb3JmbG93LkZ1bmN0aW9uU3BlYy5K",
            "aXRDb21waWxlIioKCkppdENvbXBpbGUSCwoHREVGQVVMVBAAEgYKAk9OEAES",
            "BwoDT0ZGEAJKBAgDEARKBAgEEAUiHwoNU2F2ZWRSZXNvdXJjZRIOCgZkZXZp",
            "Y2UYASABKAkiQQoOU2F2ZWFibGVPYmplY3QSFQoNc2F2ZV9mdW5jdGlvbhgC",
            "IAEoBRIYChByZXN0b3JlX2Z1bmN0aW9uGAMgASgFQlpaVWdpdGh1Yi5jb20v",
            "dGVuc29yZmxvdy90ZW5zb3JmbG93L3RlbnNvcmZsb3cvZ28vY29yZS9wcm90",
            "b2J1Zi9mb3JfY29yZV9wcm90b3NfZ29fcHJvdG/4AQFiBnByb3RvMw=="));
      descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,
          new pbr::FileDescriptor[] { global::Tensorflow.TensorShapeReflection.Descriptor, global::Tensorflow.TypesReflection.Descriptor, global::Tensorflow.VariableReflection.Descriptor, global::Tensorflow.VersionsReflection.Descriptor, global::Tensorflow.StructReflection.Descriptor, global::Tensorflow.TrackableObjectGraphReflection.Descriptor, },
          new pbr::GeneratedClrTypeInfo(null, null, new pbr::GeneratedClrTypeInfo[] {
            new pbr::GeneratedClrTypeInfo(typeof(global::Tensorflow.SavedObjectGraph), global::Tensorflow.SavedObjectGraph.Parser, new[]{ "Nodes", "ConcreteFunctions" }, null, null, null, new pbr::GeneratedClrTypeInfo[] { null, }),
            new pbr::GeneratedClrTypeInfo(typeof(global::Tensorflow.SavedObject), global::Tensorflow.SavedObject.Parser, new[]{ "Children", "SlotVariables", "UserObject", "Asset", "Function", "Variable", "BareConcreteFunction", "Constant", "Resource", "CapturedTensor", "SaveableObjects" }, new[]{ "Kind" }, null, null, new pbr::GeneratedClrTypeInfo[] { null, }),
            new pbr::GeneratedClrTypeInfo(typeof(global::Tensorflow.SavedUserObject), global::Tensorflow.SavedUserObject.Parser, new[]{ "Identifier", "Version", "Metadata" }, null, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(global::Tensorflow.SavedAsset), global::Tensorflow.SavedAsset.Parser, new[]{ "AssetFileDefIndex" }, null, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(global::Tensorflow.SavedFunction), global::Tensorflow.SavedFunction.Parser, new[]{ "ConcreteFunctions", "FunctionSpec" }, null, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(global::Tensorflow.CapturedTensor), global::Tensorflow.CapturedTensor.Parser, new[]{ "Name", "ConcreteFunction" }, null, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(global::Tensorflow.SavedConcreteFunction), global::Tensorflow.SavedConcreteFunction.Parser, new[]{ "BoundInputs", "CanonicalizedInputSignature", "OutputSignature" }, null, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(global::Tensorflow.SavedBareConcreteFunction), global::Tensorflow.SavedBareConcreteFunction.Parser, new[]{ "ConcreteFunctionName", "ArgumentKeywords", "AllowedPositionalArguments", "FunctionSpec" }, null, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(global::Tensorflow.SavedConstant), global::Tensorflow.SavedConstant.Parser, new[]{ "Operation" }, null, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(global::Tensorflow.SavedVariable), global::Tensorflow.SavedVariable.Parser, new[]{ "Dtype", "Shape", "Trainable", "Synchronization", "Aggregation", "Name", "Device", "ExperimentalDistributedVariableComponents" }, null, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(global::Tensorflow.FunctionSpec), global::Tensorflow.FunctionSpec.Parser, new[]{ "Fullargspec", "IsMethod", "InputSignature", "JitCompile" }, null, new[]{ typeof(global::Tensorflow.FunctionSpec.Types.JitCompile) }, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(global::Tensorflow.SavedResource), global::Tensorflow.SavedResource.Parser, new[]{ "Device" }, null, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(global::Tensorflow.SaveableObject), global::Tensorflow.SaveableObject.Parser, new[]{ "SaveFunction", "RestoreFunction" }, null, null, null, null)
          }));
    }
    #endregion

  }
  #region Messages
  public sealed partial class SavedObjectGraph : pb::IMessage<SavedObjectGraph> {
    private static readonly pb::MessageParser<SavedObjectGraph> _parser = new pb::MessageParser<SavedObjectGraph>(() => new SavedObjectGraph());
    private pb::UnknownFieldSet _unknownFields;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pb::MessageParser<SavedObjectGraph> Parser { get { return _parser; } }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pbr::MessageDescriptor Descriptor {
      get { return global::Tensorflow.SavedObjectGraphReflection.Descriptor.MessageTypes[0]; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    pbr::MessageDescriptor pb::IMessage.Descriptor {
      get { return Descriptor; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public SavedObjectGraph() {
      OnConstruction();
    }

    partial void OnConstruction();

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public SavedObjectGraph(SavedObjectGraph other) : this() {
      nodes_ = other.nodes_.Clone();
      concreteFunctions_ = other.concreteFunctions_.Clone();
      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public SavedObjectGraph Clone() {
      return new SavedObjectGraph(this);
    }

    /// <summary>Field number for the "nodes" field.</summary>
    public const int NodesFieldNumber = 1;
    private static readonly pb::FieldCodec<global::Tensorflow.SavedObject> _repeated_nodes_codec
        = pb::FieldCodec.ForMessage(10, global::Tensorflow.SavedObject.Parser);
    private readonly pbc::RepeatedField<global::Tensorflow.SavedObject> nodes_ = new pbc::RepeatedField<global::Tensorflow.SavedObject>();
    /// <summary>
    /// Flattened list of objects in the object graph.
    ///
    /// The position of the object in this list indicates its id.
    /// Nodes[0] is considered the root node.
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<global::Tensorflow.SavedObject>  Nodes {
      get { return nodes_; }
    }

    /// <summary>Field number for the "concrete_functions" field.</summary>
    public const int ConcreteFunctionsFieldNumber = 2;
    private static readonly pbc::MapField<string, global::Tensorflow.SavedConcreteFunction>.Codec _map_concreteFunctions_codec
        = new pbc::MapField<string, global::Tensorflow.SavedConcreteFunction>.Codec(pb::FieldCodec.ForString(10, ""), pb::FieldCodec.ForMessage(18, global::Tensorflow.SavedConcreteFunction.Parser), 18);
    private readonly pbc::MapField<string, global::Tensorflow.SavedConcreteFunction> concreteFunctions_ = new pbc::MapField<string, global::Tensorflow.SavedConcreteFunction>();
    /// <summary>
    /// Information about captures and output structures in concrete functions.
    /// Referenced from SavedBareConcreteFunction and SavedFunction.
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::MapField<string, global::Tensorflow.SavedConcreteFunction> ConcreteFunctions {
      get { return concreteFunctions_; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override bool Equals(object other) {
      return Equals(other as SavedObjectGraph);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool Equals(SavedObjectGraph other) {
      if (ReferenceEquals(other, null)) {
        return false;
      }
      if (ReferenceEquals(other, this)) {
        return true;
      }
      if(!nodes_.Equals(other.nodes_)) return false;
      if (!ConcreteFunctions.Equals(other.ConcreteFunctions)) return false;
      return Equals(_unknownFields, other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override int GetHashCode() {
      int hash = 1;
      hash ^= nodes_.GetHashCode();
      hash ^= ConcreteFunctions.GetHashCode();
      if (_unknownFields != null) {
        hash ^= _unknownFields.GetHashCode();
      }
      return hash;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override string ToString() {
      return pb::JsonFormatter.ToDiagnosticString(this);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void WriteTo(pb::CodedOutputStream output) {
      nodes_.WriteTo(output, _repeated_nodes_codec);
      concreteFunctions_.WriteTo(output, _map_concreteFunctions_codec);
      if (_unknownFields != null) {
        _unknownFields.WriteTo(output);
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int CalculateSize() {
      int size = 0;
      size += nodes_.CalculateSize(_repeated_nodes_codec);
      size += concreteFunctions_.CalculateSize(_map_concreteFunctions_codec);
      if (_unknownFields != null) {
        size += _unknownFields.CalculateSize();
      }
      return size;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(SavedObjectGraph other) {
      if (other == null) {
        return;
      }
      nodes_.Add(other.nodes_);
      concreteFunctions_.Add(other.concreteFunctions_);
      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
            break;
          case 10: {
            nodes_.AddEntriesFrom(input, _repeated_nodes_codec);
            break;
          }
          case 18: {
            concreteFunctions_.AddEntriesFrom(input, _map_concreteFunctions_codec);
            break;
          }
        }
      }
    }

  }

  public sealed partial class SavedObject : pb::IMessage<SavedObject> {
    private static readonly pb::MessageParser<SavedObject> _parser = new pb::MessageParser<SavedObject>(() => new SavedObject());
    private pb::UnknownFieldSet _unknownFields;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pb::MessageParser<SavedObject> Parser { get { return _parser; } }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pbr::MessageDescriptor Descriptor {
      get { return global::Tensorflow.SavedObjectGraphReflection.Descriptor.MessageTypes[1]; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    pbr::MessageDescriptor pb::IMessage.Descriptor {
      get { return Descriptor; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public SavedObject() {
      OnConstruction();
    }

    partial void OnConstruction();

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public SavedObject(SavedObject other) : this() {
      children_ = other.children_.Clone();
      dependencies_ = other.dependencies_.Clone();
      slotVariables_ = other.slotVariables_.Clone();
      saveableObjects_ = other.saveableObjects_.Clone();
      switch (other.KindCase) {
        case KindOneofCase.UserObject:
          UserObject = other.UserObject.Clone();
          break;
        case KindOneofCase.Asset:
          Asset = other.Asset.Clone();
          break;
        case KindOneofCase.Function:
          Function = other.Function.Clone();
          break;
        case KindOneofCase.Variable:
          Variable = other.Variable.Clone();
          break;
        case KindOneofCase.BareConcreteFunction:
          BareConcreteFunction = other.BareConcreteFunction.Clone();
          break;
        case KindOneofCase.Constant:
          Constant = other.Constant.Clone();
          break;
        case KindOneofCase.Resource:
          Resource = other.Resource.Clone();
          break;
        case KindOneofCase.CapturedTensor:
          CapturedTensor = other.CapturedTensor.Clone();
          break;
      }

      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public SavedObject Clone() {
      return new SavedObject(this);
    }

    /// <summary>Field number for the "children" field.</summary>
    public const int ChildrenFieldNumber = 1;
    private static readonly pb::FieldCodec<global::Tensorflow.TrackableObjectGraph.Types.TrackableObject.Types.ObjectReference> _repeated_children_codec
        = pb::FieldCodec.ForMessage(10, global::Tensorflow.TrackableObjectGraph.Types.TrackableObject.Types.ObjectReference.Parser);
    private readonly pbc::RepeatedField<global::Tensorflow.TrackableObjectGraph.Types.TrackableObject.Types.ObjectReference> children_ = new pbc::RepeatedField<global::Tensorflow.TrackableObjectGraph.Types.TrackableObject.Types.ObjectReference>();
    private readonly pbc::RepeatedField<global::Tensorflow.TrackableObjectGraph.Types.TrackableObject.Types.ObjectReference> dependencies_ = new pbc::RepeatedField<global::Tensorflow.TrackableObjectGraph.Types.TrackableObject.Types.ObjectReference>();
    /// <summary>
    /// Objects which this object depends on: named edges in the dependency
    /// graph.
    ///
    /// Note: currently only valid if kind == "user_object" or "resource".
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<global::Tensorflow.TrackableObjectGraph.Types.TrackableObject.Types.ObjectReference> Children {
      get { return children_; }
    }
    
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<global::Tensorflow.TrackableObjectGraph.Types.TrackableObject.Types.ObjectReference> Dependencies {
      get { return dependencies_; }
    }

    /// <summary>Field number for the "slot_variables" field.</summary>
    public const int SlotVariablesFieldNumber = 3;
    private static readonly pb::FieldCodec<global::Tensorflow.TrackableObjectGraph.Types.TrackableObject.Types.SlotVariableReference> _repeated_slotVariables_codec
        = pb::FieldCodec.ForMessage(26, global::Tensorflow.TrackableObjectGraph.Types.TrackableObject.Types.SlotVariableReference.Parser);
    private readonly pbc::RepeatedField<global::Tensorflow.TrackableObjectGraph.Types.TrackableObject.Types.SlotVariableReference> slotVariables_ = new pbc::RepeatedField<global::Tensorflow.TrackableObjectGraph.Types.TrackableObject.Types.SlotVariableReference>();
    /// <summary>
    /// Slot variables owned by this object. This describes the three-way
    /// (optimizer, variable, slot variable) relationship; none of the three
    /// depend on the others directly.
    ///
    /// Note: currently only valid if kind == "user_object".
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<global::Tensorflow.TrackableObjectGraph.Types.TrackableObject.Types.SlotVariableReference> SlotVariables {
      get { return slotVariables_; }
    }

    /// <summary>Field number for the "user_object" field.</summary>
    public const int UserObjectFieldNumber = 4;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public global::Tensorflow.SavedUserObject UserObject {
      get { return kindCase_ == KindOneofCase.UserObject ? (global::Tensorflow.SavedUserObject) kind_ : null; }
      set {
        kind_ = value;
        kindCase_ = value == null ? KindOneofCase.None : KindOneofCase.UserObject;
      }
    }

    /// <summary>Field number for the "asset" field.</summary>
    public const int AssetFieldNumber = 5;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public global::Tensorflow.SavedAsset Asset {
      get { return kindCase_ == KindOneofCase.Asset ? (global::Tensorflow.SavedAsset) kind_ : null; }
      set {
        kind_ = value;
        kindCase_ = value == null ? KindOneofCase.None : KindOneofCase.Asset;
      }
    }

    /// <summary>Field number for the "function" field.</summary>
    public const int FunctionFieldNumber = 6;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public global::Tensorflow.SavedFunction Function {
      get { return kindCase_ == KindOneofCase.Function ? (global::Tensorflow.SavedFunction) kind_ : null; }
      set {
        kind_ = value;
        kindCase_ = value == null ? KindOneofCase.None : KindOneofCase.Function;
      }
    }

    /// <summary>Field number for the "variable" field.</summary>
    public const int VariableFieldNumber = 7;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public global::Tensorflow.SavedVariable Variable {
      get { return kindCase_ == KindOneofCase.Variable ? (global::Tensorflow.SavedVariable) kind_ : null; }
      set {
        kind_ = value;
        kindCase_ = value == null ? KindOneofCase.None : KindOneofCase.Variable;
      }
    }

    /// <summary>Field number for the "bare_concrete_function" field.</summary>
    public const int BareConcreteFunctionFieldNumber = 8;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public global::Tensorflow.SavedBareConcreteFunction BareConcreteFunction {
      get { return kindCase_ == KindOneofCase.BareConcreteFunction ? (global::Tensorflow.SavedBareConcreteFunction) kind_ : null; }
      set {
        kind_ = value;
        kindCase_ = value == null ? KindOneofCase.None : KindOneofCase.BareConcreteFunction;
      }
    }

    /// <summary>Field number for the "constant" field.</summary>
    public const int ConstantFieldNumber = 9;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public global::Tensorflow.SavedConstant Constant {
      get { return kindCase_ == KindOneofCase.Constant ? (global::Tensorflow.SavedConstant) kind_ : null; }
      set {
        kind_ = value;
        kindCase_ = value == null ? KindOneofCase.None : KindOneofCase.Constant;
      }
    }

    /// <summary>Field number for the "resource" field.</summary>
    public const int ResourceFieldNumber = 10;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public global::Tensorflow.SavedResource Resource {
      get { return kindCase_ == KindOneofCase.Resource ? (global::Tensorflow.SavedResource) kind_ : null; }
      set {
        kind_ = value;
        kindCase_ = value == null ? KindOneofCase.None : KindOneofCase.Resource;
      }
    }

    /// <summary>Field number for the "captured_tensor" field.</summary>
    public const int CapturedTensorFieldNumber = 12;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public global::Tensorflow.CapturedTensor CapturedTensor {
      get { return kindCase_ == KindOneofCase.CapturedTensor ? (global::Tensorflow.CapturedTensor) kind_ : null; }
      set {
        kind_ = value;
        kindCase_ = value == null ? KindOneofCase.None : KindOneofCase.CapturedTensor;
      }
    }

    /// <summary>Field number for the "saveable_objects" field.</summary>
    public const int SaveableObjectsFieldNumber = 11;
    private static readonly pbc::MapField<string, global::Tensorflow.SaveableObject>.Codec _map_saveableObjects_codec
        = new pbc::MapField<string, global::Tensorflow.SaveableObject>.Codec(pb::FieldCodec.ForString(10, ""), pb::FieldCodec.ForMessage(18, global::Tensorflow.SaveableObject.Parser), 90);
    private readonly pbc::MapField<string, global::Tensorflow.SaveableObject> saveableObjects_ = new pbc::MapField<string, global::Tensorflow.SaveableObject>();
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::MapField<string, global::Tensorflow.SaveableObject> SaveableObjects {
      get { return saveableObjects_; }
    }

    private object kind_;
    /// <summary>Enum of possible cases for the "kind" oneof.</summary>
    public enum KindOneofCase {
      None = 0,
      UserObject = 4,
      Asset = 5,
      Function = 6,
      Variable = 7,
      BareConcreteFunction = 8,
      Constant = 9,
      Resource = 10,
      CapturedTensor = 12,
    }
    private KindOneofCase kindCase_ = KindOneofCase.None;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public KindOneofCase KindCase {
      get { return kindCase_; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void ClearKind() {
      kindCase_ = KindOneofCase.None;
      kind_ = null;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override bool Equals(object other) {
      return Equals(other as SavedObject);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool Equals(SavedObject other) {
      if (ReferenceEquals(other, null)) {
        return false;
      }
      if (ReferenceEquals(other, this)) {
        return true;
      }
      if(!children_.Equals(other.children_)) return false;
      if(!slotVariables_.Equals(other.slotVariables_)) return false;
      if (!object.Equals(UserObject, other.UserObject)) return false;
      if (!object.Equals(Asset, other.Asset)) return false;
      if (!object.Equals(Function, other.Function)) return false;
      if (!object.Equals(Variable, other.Variable)) return false;
      if (!object.Equals(BareConcreteFunction, other.BareConcreteFunction)) return false;
      if (!object.Equals(Constant, other.Constant)) return false;
      if (!object.Equals(Resource, other.Resource)) return false;
      if (!object.Equals(CapturedTensor, other.CapturedTensor)) return false;
      if (!SaveableObjects.Equals(other.SaveableObjects)) return false;
      if (KindCase != other.KindCase) return false;
      return Equals(_unknownFields, other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override int GetHashCode() {
      int hash = 1;
      hash ^= children_.GetHashCode();
      hash ^= slotVariables_.GetHashCode();
      if (kindCase_ == KindOneofCase.UserObject) hash ^= UserObject.GetHashCode();
      if (kindCase_ == KindOneofCase.Asset) hash ^= Asset.GetHashCode();
      if (kindCase_ == KindOneofCase.Function) hash ^= Function.GetHashCode();
      if (kindCase_ == KindOneofCase.Variable) hash ^= Variable.GetHashCode();
      if (kindCase_ == KindOneofCase.BareConcreteFunction) hash ^= BareConcreteFunction.GetHashCode();
      if (kindCase_ == KindOneofCase.Constant) hash ^= Constant.GetHashCode();
      if (kindCase_ == KindOneofCase.Resource) hash ^= Resource.GetHashCode();
      if (kindCase_ == KindOneofCase.CapturedTensor) hash ^= CapturedTensor.GetHashCode();
      hash ^= SaveableObjects.GetHashCode();
      hash ^= (int) kindCase_;
      if (_unknownFields != null) {
        hash ^= _unknownFields.GetHashCode();
      }
      return hash;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override string ToString() {
      return pb::JsonFormatter.ToDiagnosticString(this);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void WriteTo(pb::CodedOutputStream output) {
      children_.WriteTo(output, _repeated_children_codec);
      slotVariables_.WriteTo(output, _repeated_slotVariables_codec);
      if (kindCase_ == KindOneofCase.UserObject) {
        output.WriteRawTag(34);
        output.WriteMessage(UserObject);
      }
      if (kindCase_ == KindOneofCase.Asset) {
        output.WriteRawTag(42);
        output.WriteMessage(Asset);
      }
      if (kindCase_ == KindOneofCase.Function) {
        output.WriteRawTag(50);
        output.WriteMessage(Function);
      }
      if (kindCase_ == KindOneofCase.Variable) {
        output.WriteRawTag(58);
        output.WriteMessage(Variable);
      }
      if (kindCase_ == KindOneofCase.BareConcreteFunction) {
        output.WriteRawTag(66);
        output.WriteMessage(BareConcreteFunction);
      }
      if (kindCase_ == KindOneofCase.Constant) {
        output.WriteRawTag(74);
        output.WriteMessage(Constant);
      }
      if (kindCase_ == KindOneofCase.Resource) {
        output.WriteRawTag(82);
        output.WriteMessage(Resource);
      }
      saveableObjects_.WriteTo(output, _map_saveableObjects_codec);
      if (kindCase_ == KindOneofCase.CapturedTensor) {
        output.WriteRawTag(98);
        output.WriteMessage(CapturedTensor);
      }
      if (_unknownFields != null) {
        _unknownFields.WriteTo(output);
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int CalculateSize() {
      int size = 0;
      size += children_.CalculateSize(_repeated_children_codec);
      size += slotVariables_.CalculateSize(_repeated_slotVariables_codec);
      if (kindCase_ == KindOneofCase.UserObject) {
        size += 1 + pb::CodedOutputStream.ComputeMessageSize(UserObject);
      }
      if (kindCase_ == KindOneofCase.Asset) {
        size += 1 + pb::CodedOutputStream.ComputeMessageSize(Asset);
      }
      if (kindCase_ == KindOneofCase.Function) {
        size += 1 + pb::CodedOutputStream.ComputeMessageSize(Function);
      }
      if (kindCase_ == KindOneofCase.Variable) {
        size += 1 + pb::CodedOutputStream.ComputeMessageSize(Variable);
      }
      if (kindCase_ == KindOneofCase.BareConcreteFunction) {
        size += 1 + pb::CodedOutputStream.ComputeMessageSize(BareConcreteFunction);
      }
      if (kindCase_ == KindOneofCase.Constant) {
        size += 1 + pb::CodedOutputStream.ComputeMessageSize(Constant);
      }
      if (kindCase_ == KindOneofCase.Resource) {
        size += 1 + pb::CodedOutputStream.ComputeMessageSize(Resource);
      }
      if (kindCase_ == KindOneofCase.CapturedTensor) {
        size += 1 + pb::CodedOutputStream.ComputeMessageSize(CapturedTensor);
      }
      size += saveableObjects_.CalculateSize(_map_saveableObjects_codec);
      if (_unknownFields != null) {
        size += _unknownFields.CalculateSize();
      }
      return size;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(SavedObject other) {
      if (other == null) {
        return;
      }
      children_.Add(other.children_);
      dependencies_.Add(other.dependencies_);
      slotVariables_.Add(other.slotVariables_);
      saveableObjects_.Add(other.saveableObjects_);
      switch (other.KindCase) {
        case KindOneofCase.UserObject:
          if (UserObject == null) {
            UserObject = new global::Tensorflow.SavedUserObject();
          }
          UserObject.MergeFrom(other.UserObject);
          break;
        case KindOneofCase.Asset:
          if (Asset == null) {
            Asset = new global::Tensorflow.SavedAsset();
          }
          Asset.MergeFrom(other.Asset);
          break;
        case KindOneofCase.Function:
          if (Function == null) {
            Function = new global::Tensorflow.SavedFunction();
          }
          Function.MergeFrom(other.Function);
          break;
        case KindOneofCase.Variable:
          if (Variable == null) {
            Variable = new global::Tensorflow.SavedVariable();
          }
          Variable.MergeFrom(other.Variable);
          break;
        case KindOneofCase.BareConcreteFunction:
          if (BareConcreteFunction == null) {
            BareConcreteFunction = new global::Tensorflow.SavedBareConcreteFunction();
          }
          BareConcreteFunction.MergeFrom(other.BareConcreteFunction);
          break;
        case KindOneofCase.Constant:
          if (Constant == null) {
            Constant = new global::Tensorflow.SavedConstant();
          }
          Constant.MergeFrom(other.Constant);
          break;
        case KindOneofCase.Resource:
          if (Resource == null) {
            Resource = new global::Tensorflow.SavedResource();
          }
          Resource.MergeFrom(other.Resource);
          break;
        case KindOneofCase.CapturedTensor:
          if (CapturedTensor == null) {
            CapturedTensor = new global::Tensorflow.CapturedTensor();
          }
          CapturedTensor.MergeFrom(other.CapturedTensor);
          break;
      }

      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
            break;
          case 10: {
            children_.AddEntriesFrom(input, _repeated_children_codec);
            break;
          }
          case 26: {
            slotVariables_.AddEntriesFrom(input, _repeated_slotVariables_codec);
            break;
          }
          case 34: {
            global::Tensorflow.SavedUserObject subBuilder = new global::Tensorflow.SavedUserObject();
            if (kindCase_ == KindOneofCase.UserObject) {
              subBuilder.MergeFrom(UserObject);
            }
            input.ReadMessage(subBuilder);
            UserObject = subBuilder;
            break;
          }
          case 42: {
            global::Tensorflow.SavedAsset subBuilder = new global::Tensorflow.SavedAsset();
            if (kindCase_ == KindOneofCase.Asset) {
              subBuilder.MergeFrom(Asset);
            }
            input.ReadMessage(subBuilder);
            Asset = subBuilder;
            break;
          }
          case 50: {
            global::Tensorflow.SavedFunction subBuilder = new global::Tensorflow.SavedFunction();
            if (kindCase_ == KindOneofCase.Function) {
              subBuilder.MergeFrom(Function);
            }
            input.ReadMessage(subBuilder);
            Function = subBuilder;
            break;
          }
          case 58: {
            global::Tensorflow.SavedVariable subBuilder = new global::Tensorflow.SavedVariable();
            if (kindCase_ == KindOneofCase.Variable) {
              subBuilder.MergeFrom(Variable);
            }
            input.ReadMessage(subBuilder);
            Variable = subBuilder;
            break;
          }
          case 66: {
            global::Tensorflow.SavedBareConcreteFunction subBuilder = new global::Tensorflow.SavedBareConcreteFunction();
            if (kindCase_ == KindOneofCase.BareConcreteFunction) {
              subBuilder.MergeFrom(BareConcreteFunction);
            }
            input.ReadMessage(subBuilder);
            BareConcreteFunction = subBuilder;
            break;
          }
          case 74: {
            global::Tensorflow.SavedConstant subBuilder = new global::Tensorflow.SavedConstant();
            if (kindCase_ == KindOneofCase.Constant) {
              subBuilder.MergeFrom(Constant);
            }
            input.ReadMessage(subBuilder);
            Constant = subBuilder;
            break;
          }
          case 82: {
            global::Tensorflow.SavedResource subBuilder = new global::Tensorflow.SavedResource();
            if (kindCase_ == KindOneofCase.Resource) {
              subBuilder.MergeFrom(Resource);
            }
            input.ReadMessage(subBuilder);
            Resource = subBuilder;
            break;
          }
          case 90: {
            saveableObjects_.AddEntriesFrom(input, _map_saveableObjects_codec);
            break;
          }
          case 98: {
            global::Tensorflow.CapturedTensor subBuilder = new global::Tensorflow.CapturedTensor();
            if (kindCase_ == KindOneofCase.CapturedTensor) {
              subBuilder.MergeFrom(CapturedTensor);
            }
            input.ReadMessage(subBuilder);
            CapturedTensor = subBuilder;
            break;
          }
        }
      }
    }

  }

  /// <summary>
  /// A SavedUserObject is an object (in the object-oriented language of the
  /// TensorFlow program) of some user- or framework-defined class other than
  /// those handled specifically by the other kinds of SavedObjects.
  ///
  /// This object cannot be evaluated as a tensor, and therefore cannot be bound
  /// to an input of a function.
  /// </summary>
  public sealed partial class SavedUserObject : pb::IMessage<SavedUserObject> {
    private static readonly pb::MessageParser<SavedUserObject> _parser = new pb::MessageParser<SavedUserObject>(() => new SavedUserObject());
    private pb::UnknownFieldSet _unknownFields;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pb::MessageParser<SavedUserObject> Parser { get { return _parser; } }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pbr::MessageDescriptor Descriptor {
      get { return global::Tensorflow.SavedObjectGraphReflection.Descriptor.MessageTypes[2]; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    pbr::MessageDescriptor pb::IMessage.Descriptor {
      get { return Descriptor; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public SavedUserObject() {
      OnConstruction();
    }

    partial void OnConstruction();

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public SavedUserObject(SavedUserObject other) : this() {
      identifier_ = other.identifier_;
      version_ = other.version_ != null ? other.version_.Clone() : null;
      metadata_ = other.metadata_;
      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public SavedUserObject Clone() {
      return new SavedUserObject(this);
    }

    /// <summary>Field number for the "identifier" field.</summary>
    public const int IdentifierFieldNumber = 1;
    private string identifier_ = "";
    /// <summary>
    /// Corresponds to a registration of the type to use in the loading program.
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public string Identifier {
      get { return identifier_; }
      set {
        identifier_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
      }
    }

    /// <summary>Field number for the "version" field.</summary>
    public const int VersionFieldNumber = 2;
    private global::Tensorflow.VersionDef version_;
    /// <summary>
    /// Version information from the producer of this SavedUserObject.
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public global::Tensorflow.VersionDef Version {
      get { return version_; }
      set {
        version_ = value;
      }
    }

    /// <summary>Field number for the "metadata" field.</summary>
    public const int MetadataFieldNumber = 3;
    private string metadata_ = "";
    /// <summary>
    /// Metadata for deserializing this object.
    ///
    /// Deprecated! At the time of deprecation, Keras was the only user of this
    /// field, and its saving and loading code will be updated shortly.
    /// Please save your application-specific metadata to a separate file.
    /// </summary>
    [global::System.ObsoleteAttribute]
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public string Metadata {
      get { return metadata_; }
      set {
        metadata_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override bool Equals(object other) {
      return Equals(other as SavedUserObject);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool Equals(SavedUserObject other) {
      if (ReferenceEquals(other, null)) {
        return false;
      }
      if (ReferenceEquals(other, this)) {
        return true;
      }
      if (Identifier != other.Identifier) return false;
      if (!object.Equals(Version, other.Version)) return false;
      if (Metadata != other.Metadata) return false;
      return Equals(_unknownFields, other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override int GetHashCode() {
      int hash = 1;
      if (Identifier.Length != 0) hash ^= Identifier.GetHashCode();
      if (version_ != null) hash ^= Version.GetHashCode();
      if (Metadata.Length != 0) hash ^= Metadata.GetHashCode();
      if (_unknownFields != null) {
        hash ^= _unknownFields.GetHashCode();
      }
      return hash;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override string ToString() {
      return pb::JsonFormatter.ToDiagnosticString(this);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void WriteTo(pb::CodedOutputStream output) {
      if (Identifier.Length != 0) {
        output.WriteRawTag(10);
        output.WriteString(Identifier);
      }
      if (version_ != null) {
        output.WriteRawTag(18);
        output.WriteMessage(Version);
      }
      if (Metadata.Length != 0) {
        output.WriteRawTag(26);
        output.WriteString(Metadata);
      }
      if (_unknownFields != null) {
        _unknownFields.WriteTo(output);
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int CalculateSize() {
      int size = 0;
      if (Identifier.Length != 0) {
        size += 1 + pb::CodedOutputStream.ComputeStringSize(Identifier);
      }
      if (version_ != null) {
        size += 1 + pb::CodedOutputStream.ComputeMessageSize(Version);
      }
      if (Metadata.Length != 0) {
        size += 1 + pb::CodedOutputStream.ComputeStringSize(Metadata);
      }
      if (_unknownFields != null) {
        size += _unknownFields.CalculateSize();
      }
      return size;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(SavedUserObject other) {
      if (other == null) {
        return;
      }
      if (other.Identifier.Length != 0) {
        Identifier = other.Identifier;
      }
      if (other.version_ != null) {
        if (version_ == null) {
          Version = new global::Tensorflow.VersionDef();
        }
        Version.MergeFrom(other.Version);
      }
      if (other.Metadata.Length != 0) {
        Metadata = other.Metadata;
      }
      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
            break;
          case 10: {
            Identifier = input.ReadString();
            break;
          }
          case 18: {
            if (version_ == null) {
              Version = new global::Tensorflow.VersionDef();
            }
            input.ReadMessage(Version);
            break;
          }
          case 26: {
            Metadata = input.ReadString();
            break;
          }
        }
      }
    }

  }

  /// <summary>
  /// A SavedAsset points to an asset in the MetaGraph.
  ///
  /// When bound to a function this object evaluates to a tensor with the absolute
  /// filename. Users should not depend on a particular part of the filename to
  /// remain stable (e.g. basename could be changed).
  /// </summary>
  public sealed partial class SavedAsset : pb::IMessage<SavedAsset> {
    private static readonly pb::MessageParser<SavedAsset> _parser = new pb::MessageParser<SavedAsset>(() => new SavedAsset());
    private pb::UnknownFieldSet _unknownFields;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pb::MessageParser<SavedAsset> Parser { get { return _parser; } }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pbr::MessageDescriptor Descriptor {
      get { return global::Tensorflow.SavedObjectGraphReflection.Descriptor.MessageTypes[3]; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    pbr::MessageDescriptor pb::IMessage.Descriptor {
      get { return Descriptor; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public SavedAsset() {
      OnConstruction();
    }

    partial void OnConstruction();

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public SavedAsset(SavedAsset other) : this() {
      assetFileDefIndex_ = other.assetFileDefIndex_;
      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public SavedAsset Clone() {
      return new SavedAsset(this);
    }

    /// <summary>Field number for the "asset_file_def_index" field.</summary>
    public const int AssetFileDefIndexFieldNumber = 1;
    private int assetFileDefIndex_;
    /// <summary>
    /// Index into `MetaGraphDef.asset_file_def[]` that describes the Asset.
    ///
    /// Only the field `AssetFileDef.filename` is used. Other fields, such as
    /// `AssetFileDef.tensor_info`, MUST be ignored.
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int AssetFileDefIndex {
      get { return assetFileDefIndex_; }
      set {
        assetFileDefIndex_ = value;
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override bool Equals(object other) {
      return Equals(other as SavedAsset);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool Equals(SavedAsset other) {
      if (ReferenceEquals(other, null)) {
        return false;
      }
      if (ReferenceEquals(other, this)) {
        return true;
      }
      if (AssetFileDefIndex != other.AssetFileDefIndex) return false;
      return Equals(_unknownFields, other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override int GetHashCode() {
      int hash = 1;
      if (AssetFileDefIndex != 0) hash ^= AssetFileDefIndex.GetHashCode();
      if (_unknownFields != null) {
        hash ^= _unknownFields.GetHashCode();
      }
      return hash;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override string ToString() {
      return pb::JsonFormatter.ToDiagnosticString(this);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void WriteTo(pb::CodedOutputStream output) {
      if (AssetFileDefIndex != 0) {
        output.WriteRawTag(8);
        output.WriteInt32(AssetFileDefIndex);
      }
      if (_unknownFields != null) {
        _unknownFields.WriteTo(output);
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int CalculateSize() {
      int size = 0;
      if (AssetFileDefIndex != 0) {
        size += 1 + pb::CodedOutputStream.ComputeInt32Size(AssetFileDefIndex);
      }
      if (_unknownFields != null) {
        size += _unknownFields.CalculateSize();
      }
      return size;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(SavedAsset other) {
      if (other == null) {
        return;
      }
      if (other.AssetFileDefIndex != 0) {
        AssetFileDefIndex = other.AssetFileDefIndex;
      }
      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
            break;
          case 8: {
            AssetFileDefIndex = input.ReadInt32();
            break;
          }
        }
      }
    }

  }

  /// <summary>
  /// A function with multiple signatures, possibly with non-Tensor arguments.
  /// </summary>
  public sealed partial class SavedFunction : pb::IMessage<SavedFunction> {
    private static readonly pb::MessageParser<SavedFunction> _parser = new pb::MessageParser<SavedFunction>(() => new SavedFunction());
    private pb::UnknownFieldSet _unknownFields;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pb::MessageParser<SavedFunction> Parser { get { return _parser; } }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pbr::MessageDescriptor Descriptor {
      get { return global::Tensorflow.SavedObjectGraphReflection.Descriptor.MessageTypes[4]; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    pbr::MessageDescriptor pb::IMessage.Descriptor {
      get { return Descriptor; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public SavedFunction() {
      OnConstruction();
    }

    partial void OnConstruction();

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public SavedFunction(SavedFunction other) : this() {
      concreteFunctions_ = other.concreteFunctions_.Clone();
      functionSpec_ = other.functionSpec_ != null ? other.functionSpec_.Clone() : null;
      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public SavedFunction Clone() {
      return new SavedFunction(this);
    }

    /// <summary>Field number for the "concrete_functions" field.</summary>
    public const int ConcreteFunctionsFieldNumber = 1;
    private static readonly pb::FieldCodec<string> _repeated_concreteFunctions_codec
        = pb::FieldCodec.ForString(10);
    private readonly pbc::RepeatedField<string> concreteFunctions_ = new pbc::RepeatedField<string>();
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<string> ConcreteFunctions {
      get { return concreteFunctions_; }
    }

    /// <summary>Field number for the "function_spec" field.</summary>
    public const int FunctionSpecFieldNumber = 2;
    private global::Tensorflow.FunctionSpec functionSpec_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public global::Tensorflow.FunctionSpec FunctionSpec {
      get { return functionSpec_; }
      set {
        functionSpec_ = value;
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override bool Equals(object other) {
      return Equals(other as SavedFunction);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool Equals(SavedFunction other) {
      if (ReferenceEquals(other, null)) {
        return false;
      }
      if (ReferenceEquals(other, this)) {
        return true;
      }
      if(!concreteFunctions_.Equals(other.concreteFunctions_)) return false;
      if (!object.Equals(FunctionSpec, other.FunctionSpec)) return false;
      return Equals(_unknownFields, other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override int GetHashCode() {
      int hash = 1;
      hash ^= concreteFunctions_.GetHashCode();
      if (functionSpec_ != null) hash ^= FunctionSpec.GetHashCode();
      if (_unknownFields != null) {
        hash ^= _unknownFields.GetHashCode();
      }
      return hash;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override string ToString() {
      return pb::JsonFormatter.ToDiagnosticString(this);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void WriteTo(pb::CodedOutputStream output) {
      concreteFunctions_.WriteTo(output, _repeated_concreteFunctions_codec);
      if (functionSpec_ != null) {
        output.WriteRawTag(18);
        output.WriteMessage(FunctionSpec);
      }
      if (_unknownFields != null) {
        _unknownFields.WriteTo(output);
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int CalculateSize() {
      int size = 0;
      size += concreteFunctions_.CalculateSize(_repeated_concreteFunctions_codec);
      if (functionSpec_ != null) {
        size += 1 + pb::CodedOutputStream.ComputeMessageSize(FunctionSpec);
      }
      if (_unknownFields != null) {
        size += _unknownFields.CalculateSize();
      }
      return size;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(SavedFunction other) {
      if (other == null) {
        return;
      }
      concreteFunctions_.Add(other.concreteFunctions_);
      if (other.functionSpec_ != null) {
        if (functionSpec_ == null) {
          FunctionSpec = new global::Tensorflow.FunctionSpec();
        }
        FunctionSpec.MergeFrom(other.FunctionSpec);
      }
      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
            break;
          case 10: {
            concreteFunctions_.AddEntriesFrom(input, _repeated_concreteFunctions_codec);
            break;
          }
          case 18: {
            if (functionSpec_ == null) {
              FunctionSpec = new global::Tensorflow.FunctionSpec();
            }
            input.ReadMessage(FunctionSpec);
            break;
          }
        }
      }
    }

  }

  public sealed partial class CapturedTensor : pb::IMessage<CapturedTensor> {
    private static readonly pb::MessageParser<CapturedTensor> _parser = new pb::MessageParser<CapturedTensor>(() => new CapturedTensor());
    private pb::UnknownFieldSet _unknownFields;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pb::MessageParser<CapturedTensor> Parser { get { return _parser; } }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pbr::MessageDescriptor Descriptor {
      get { return global::Tensorflow.SavedObjectGraphReflection.Descriptor.MessageTypes[5]; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    pbr::MessageDescriptor pb::IMessage.Descriptor {
      get { return Descriptor; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public CapturedTensor() {
      OnConstruction();
    }

    partial void OnConstruction();

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public CapturedTensor(CapturedTensor other) : this() {
      name_ = other.name_;
      concreteFunction_ = other.concreteFunction_;
      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public CapturedTensor Clone() {
      return new CapturedTensor(this);
    }

    /// <summary>Field number for the "name" field.</summary>
    public const int NameFieldNumber = 1;
    private string name_ = "";
    /// <summary>
    /// Name of captured tensor
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public string Name {
      get { return name_; }
      set {
        name_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
      }
    }

    /// <summary>Field number for the "concrete_function" field.</summary>
    public const int ConcreteFunctionFieldNumber = 2;
    private string concreteFunction_ = "";
    /// <summary>
    /// Name of concrete function which contains the computed graph tensor.
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public string ConcreteFunction {
      get { return concreteFunction_; }
      set {
        concreteFunction_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override bool Equals(object other) {
      return Equals(other as CapturedTensor);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool Equals(CapturedTensor other) {
      if (ReferenceEquals(other, null)) {
        return false;
      }
      if (ReferenceEquals(other, this)) {
        return true;
      }
      if (Name != other.Name) return false;
      if (ConcreteFunction != other.ConcreteFunction) return false;
      return Equals(_unknownFields, other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override int GetHashCode() {
      int hash = 1;
      if (Name.Length != 0) hash ^= Name.GetHashCode();
      if (ConcreteFunction.Length != 0) hash ^= ConcreteFunction.GetHashCode();
      if (_unknownFields != null) {
        hash ^= _unknownFields.GetHashCode();
      }
      return hash;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override string ToString() {
      return pb::JsonFormatter.ToDiagnosticString(this);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void WriteTo(pb::CodedOutputStream output) {
      if (Name.Length != 0) {
        output.WriteRawTag(10);
        output.WriteString(Name);
      }
      if (ConcreteFunction.Length != 0) {
        output.WriteRawTag(18);
        output.WriteString(ConcreteFunction);
      }
      if (_unknownFields != null) {
        _unknownFields.WriteTo(output);
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int CalculateSize() {
      int size = 0;
      if (Name.Length != 0) {
        size += 1 + pb::CodedOutputStream.ComputeStringSize(Name);
      }
      if (ConcreteFunction.Length != 0) {
        size += 1 + pb::CodedOutputStream.ComputeStringSize(ConcreteFunction);
      }
      if (_unknownFields != null) {
        size += _unknownFields.CalculateSize();
      }
      return size;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(CapturedTensor other) {
      if (other == null) {
        return;
      }
      if (other.Name.Length != 0) {
        Name = other.Name;
      }
      if (other.ConcreteFunction.Length != 0) {
        ConcreteFunction = other.ConcreteFunction;
      }
      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
            break;
          case 10: {
            Name = input.ReadString();
            break;
          }
          case 18: {
            ConcreteFunction = input.ReadString();
            break;
          }
        }
      }
    }

  }

  /// <summary>
  /// Stores low-level information about a concrete function. Referenced in either
  /// a SavedFunction or a SavedBareConcreteFunction.
  /// </summary>
  public sealed partial class SavedConcreteFunction : pb::IMessage<SavedConcreteFunction> {
    private static readonly pb::MessageParser<SavedConcreteFunction> _parser = new pb::MessageParser<SavedConcreteFunction>(() => new SavedConcreteFunction());
    private pb::UnknownFieldSet _unknownFields;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pb::MessageParser<SavedConcreteFunction> Parser { get { return _parser; } }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pbr::MessageDescriptor Descriptor {
      get { return global::Tensorflow.SavedObjectGraphReflection.Descriptor.MessageTypes[6]; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    pbr::MessageDescriptor pb::IMessage.Descriptor {
      get { return Descriptor; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public SavedConcreteFunction() {
      OnConstruction();
    }

    partial void OnConstruction();

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public SavedConcreteFunction(SavedConcreteFunction other) : this() {
      boundInputs_ = other.boundInputs_.Clone();
      canonicalizedInputSignature_ = other.canonicalizedInputSignature_ != null ? other.canonicalizedInputSignature_.Clone() : null;
      outputSignature_ = other.outputSignature_ != null ? other.outputSignature_.Clone() : null;
      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public SavedConcreteFunction Clone() {
      return new SavedConcreteFunction(this);
    }

    /// <summary>Field number for the "bound_inputs" field.</summary>
    public const int BoundInputsFieldNumber = 2;
    private static readonly pb::FieldCodec<int> _repeated_boundInputs_codec
        = pb::FieldCodec.ForInt32(18);
    private readonly pbc::RepeatedField<int> boundInputs_ = new pbc::RepeatedField<int>();
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<int> BoundInputs {
      get { return boundInputs_; }
    }

    /// <summary>Field number for the "canonicalized_input_signature" field.</summary>
    public const int CanonicalizedInputSignatureFieldNumber = 3;
    private global::Tensorflow.StructuredValue canonicalizedInputSignature_;
    /// <summary>
    /// Input in canonicalized form that was received to create this concrete
    /// function.
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public global::Tensorflow.StructuredValue CanonicalizedInputSignature {
      get { return canonicalizedInputSignature_; }
      set {
        canonicalizedInputSignature_ = value;
      }
    }

    /// <summary>Field number for the "output_signature" field.</summary>
    public const int OutputSignatureFieldNumber = 4;
    private global::Tensorflow.StructuredValue outputSignature_;
    /// <summary>
    /// Output that was the return value of this function after replacing all
    /// Tensors with TensorSpecs. This can be an arbitrary nested function and will
    /// be used to reconstruct the full structure from pure tensors.
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public global::Tensorflow.StructuredValue OutputSignature {
      get { return outputSignature_; }
      set {
        outputSignature_ = value;
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override bool Equals(object other) {
      return Equals(other as SavedConcreteFunction);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool Equals(SavedConcreteFunction other) {
      if (ReferenceEquals(other, null)) {
        return false;
      }
      if (ReferenceEquals(other, this)) {
        return true;
      }
      if(!boundInputs_.Equals(other.boundInputs_)) return false;
      if (!object.Equals(CanonicalizedInputSignature, other.CanonicalizedInputSignature)) return false;
      if (!object.Equals(OutputSignature, other.OutputSignature)) return false;
      return Equals(_unknownFields, other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override int GetHashCode() {
      int hash = 1;
      hash ^= boundInputs_.GetHashCode();
      if (canonicalizedInputSignature_ != null) hash ^= CanonicalizedInputSignature.GetHashCode();
      if (outputSignature_ != null) hash ^= OutputSignature.GetHashCode();
      if (_unknownFields != null) {
        hash ^= _unknownFields.GetHashCode();
      }
      return hash;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override string ToString() {
      return pb::JsonFormatter.ToDiagnosticString(this);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void WriteTo(pb::CodedOutputStream output) {
      boundInputs_.WriteTo(output, _repeated_boundInputs_codec);
      if (canonicalizedInputSignature_ != null) {
        output.WriteRawTag(26);
        output.WriteMessage(CanonicalizedInputSignature);
      }
      if (outputSignature_ != null) {
        output.WriteRawTag(34);
        output.WriteMessage(OutputSignature);
      }
      if (_unknownFields != null) {
        _unknownFields.WriteTo(output);
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int CalculateSize() {
      int size = 0;
      size += boundInputs_.CalculateSize(_repeated_boundInputs_codec);
      if (canonicalizedInputSignature_ != null) {
        size += 1 + pb::CodedOutputStream.ComputeMessageSize(CanonicalizedInputSignature);
      }
      if (outputSignature_ != null) {
        size += 1 + pb::CodedOutputStream.ComputeMessageSize(OutputSignature);
      }
      if (_unknownFields != null) {
        size += _unknownFields.CalculateSize();
      }
      return size;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(SavedConcreteFunction other) {
      if (other == null) {
        return;
      }
      boundInputs_.Add(other.boundInputs_);
      if (other.canonicalizedInputSignature_ != null) {
        if (canonicalizedInputSignature_ == null) {
          CanonicalizedInputSignature = new global::Tensorflow.StructuredValue();
        }
        CanonicalizedInputSignature.MergeFrom(other.CanonicalizedInputSignature);
      }
      if (other.outputSignature_ != null) {
        if (outputSignature_ == null) {
          OutputSignature = new global::Tensorflow.StructuredValue();
        }
        OutputSignature.MergeFrom(other.OutputSignature);
      }
      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
            break;
          case 18:
          case 16: {
            boundInputs_.AddEntriesFrom(input, _repeated_boundInputs_codec);
            break;
          }
          case 26: {
            if (canonicalizedInputSignature_ == null) {
              CanonicalizedInputSignature = new global::Tensorflow.StructuredValue();
            }
            input.ReadMessage(CanonicalizedInputSignature);
            break;
          }
          case 34: {
            if (outputSignature_ == null) {
              OutputSignature = new global::Tensorflow.StructuredValue();
            }
            input.ReadMessage(OutputSignature);
            break;
          }
        }
      }
    }

  }

  public sealed partial class SavedBareConcreteFunction : pb::IMessage<SavedBareConcreteFunction> {
    private static readonly pb::MessageParser<SavedBareConcreteFunction> _parser = new pb::MessageParser<SavedBareConcreteFunction>(() => new SavedBareConcreteFunction());
    private pb::UnknownFieldSet _unknownFields;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pb::MessageParser<SavedBareConcreteFunction> Parser { get { return _parser; } }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pbr::MessageDescriptor Descriptor {
      get { return global::Tensorflow.SavedObjectGraphReflection.Descriptor.MessageTypes[7]; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    pbr::MessageDescriptor pb::IMessage.Descriptor {
      get { return Descriptor; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public SavedBareConcreteFunction() {
      OnConstruction();
    }

    partial void OnConstruction();

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public SavedBareConcreteFunction(SavedBareConcreteFunction other) : this() {
      concreteFunctionName_ = other.concreteFunctionName_;
      argumentKeywords_ = other.argumentKeywords_.Clone();
      allowedPositionalArguments_ = other.allowedPositionalArguments_;
      functionSpec_ = other.functionSpec_ != null ? other.functionSpec_.Clone() : null;
      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public SavedBareConcreteFunction Clone() {
      return new SavedBareConcreteFunction(this);
    }

    /// <summary>Field number for the "concrete_function_name" field.</summary>
    public const int ConcreteFunctionNameFieldNumber = 1;
    private string concreteFunctionName_ = "";
    /// <summary>
    /// Identifies a SavedConcreteFunction.
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public string ConcreteFunctionName {
      get { return concreteFunctionName_; }
      set {
        concreteFunctionName_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
      }
    }

    /// <summary>Field number for the "argument_keywords" field.</summary>
    public const int ArgumentKeywordsFieldNumber = 2;
    private static readonly pb::FieldCodec<string> _repeated_argumentKeywords_codec
        = pb::FieldCodec.ForString(18);
    private readonly pbc::RepeatedField<string> argumentKeywords_ = new pbc::RepeatedField<string>();
    /// <summary>
    /// A sequence of unique strings, one per Tensor argument.
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<string> ArgumentKeywords {
      get { return argumentKeywords_; }
    }

    /// <summary>Field number for the "allowed_positional_arguments" field.</summary>
    public const int AllowedPositionalArgumentsFieldNumber = 3;
    private long allowedPositionalArguments_;
    /// <summary>
    /// The prefix of `argument_keywords` which may be identified by position.
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public long AllowedPositionalArguments {
      get { return allowedPositionalArguments_; }
      set {
        allowedPositionalArguments_ = value;
      }
    }

    /// <summary>Field number for the "function_spec" field.</summary>
    public const int FunctionSpecFieldNumber = 4;
    private global::Tensorflow.FunctionSpec functionSpec_;
    /// <summary>
    /// The spec of the function that this ConcreteFunction is traced from. This
    /// allows the ConcreteFunction to be called with nest structure inputs. This
    /// field may not be populated. If this field is absent, the concrete function
    /// can only be called with flat inputs.
    /// TODO(b/169361281): support calling saved ConcreteFunction with structured
    /// inputs in C++ SavedModel API.
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public global::Tensorflow.FunctionSpec FunctionSpec {
      get { return functionSpec_; }
      set {
        functionSpec_ = value;
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override bool Equals(object other) {
      return Equals(other as SavedBareConcreteFunction);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool Equals(SavedBareConcreteFunction other) {
      if (ReferenceEquals(other, null)) {
        return false;
      }
      if (ReferenceEquals(other, this)) {
        return true;
      }
      if (ConcreteFunctionName != other.ConcreteFunctionName) return false;
      if(!argumentKeywords_.Equals(other.argumentKeywords_)) return false;
      if (AllowedPositionalArguments != other.AllowedPositionalArguments) return false;
      if (!object.Equals(FunctionSpec, other.FunctionSpec)) return false;
      return Equals(_unknownFields, other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override int GetHashCode() {
      int hash = 1;
      if (ConcreteFunctionName.Length != 0) hash ^= ConcreteFunctionName.GetHashCode();
      hash ^= argumentKeywords_.GetHashCode();
      if (AllowedPositionalArguments != 0L) hash ^= AllowedPositionalArguments.GetHashCode();
      if (functionSpec_ != null) hash ^= FunctionSpec.GetHashCode();
      if (_unknownFields != null) {
        hash ^= _unknownFields.GetHashCode();
      }
      return hash;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override string ToString() {
      return pb::JsonFormatter.ToDiagnosticString(this);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void WriteTo(pb::CodedOutputStream output) {
      if (ConcreteFunctionName.Length != 0) {
        output.WriteRawTag(10);
        output.WriteString(ConcreteFunctionName);
      }
      argumentKeywords_.WriteTo(output, _repeated_argumentKeywords_codec);
      if (AllowedPositionalArguments != 0L) {
        output.WriteRawTag(24);
        output.WriteInt64(AllowedPositionalArguments);
      }
      if (functionSpec_ != null) {
        output.WriteRawTag(34);
        output.WriteMessage(FunctionSpec);
      }
      if (_unknownFields != null) {
        _unknownFields.WriteTo(output);
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int CalculateSize() {
      int size = 0;
      if (ConcreteFunctionName.Length != 0) {
        size += 1 + pb::CodedOutputStream.ComputeStringSize(ConcreteFunctionName);
      }
      size += argumentKeywords_.CalculateSize(_repeated_argumentKeywords_codec);
      if (AllowedPositionalArguments != 0L) {
        size += 1 + pb::CodedOutputStream.ComputeInt64Size(AllowedPositionalArguments);
      }
      if (functionSpec_ != null) {
        size += 1 + pb::CodedOutputStream.ComputeMessageSize(FunctionSpec);
      }
      if (_unknownFields != null) {
        size += _unknownFields.CalculateSize();
      }
      return size;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(SavedBareConcreteFunction other) {
      if (other == null) {
        return;
      }
      if (other.ConcreteFunctionName.Length != 0) {
        ConcreteFunctionName = other.ConcreteFunctionName;
      }
      argumentKeywords_.Add(other.argumentKeywords_);
      if (other.AllowedPositionalArguments != 0L) {
        AllowedPositionalArguments = other.AllowedPositionalArguments;
      }
      if (other.functionSpec_ != null) {
        if (functionSpec_ == null) {
          FunctionSpec = new global::Tensorflow.FunctionSpec();
        }
        FunctionSpec.MergeFrom(other.FunctionSpec);
      }
      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
            break;
          case 10: {
            ConcreteFunctionName = input.ReadString();
            break;
          }
          case 18: {
            argumentKeywords_.AddEntriesFrom(input, _repeated_argumentKeywords_codec);
            break;
          }
          case 24: {
            AllowedPositionalArguments = input.ReadInt64();
            break;
          }
          case 34: {
            if (functionSpec_ == null) {
              FunctionSpec = new global::Tensorflow.FunctionSpec();
            }
            input.ReadMessage(FunctionSpec);
            break;
          }
        }
      }
    }

  }

  public sealed partial class SavedConstant : pb::IMessage<SavedConstant> {
    private static readonly pb::MessageParser<SavedConstant> _parser = new pb::MessageParser<SavedConstant>(() => new SavedConstant());
    private pb::UnknownFieldSet _unknownFields;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pb::MessageParser<SavedConstant> Parser { get { return _parser; } }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pbr::MessageDescriptor Descriptor {
      get { return global::Tensorflow.SavedObjectGraphReflection.Descriptor.MessageTypes[8]; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    pbr::MessageDescriptor pb::IMessage.Descriptor {
      get { return Descriptor; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public SavedConstant() {
      OnConstruction();
    }

    partial void OnConstruction();

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public SavedConstant(SavedConstant other) : this() {
      operation_ = other.operation_;
      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public SavedConstant Clone() {
      return new SavedConstant(this);
    }

    /// <summary>Field number for the "operation" field.</summary>
    public const int OperationFieldNumber = 1;
    private string operation_ = "";
    /// <summary>
    /// An Operation name for a ConstantOp in this SavedObjectGraph's MetaGraph.
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public string Operation {
      get { return operation_; }
      set {
        operation_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override bool Equals(object other) {
      return Equals(other as SavedConstant);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool Equals(SavedConstant other) {
      if (ReferenceEquals(other, null)) {
        return false;
      }
      if (ReferenceEquals(other, this)) {
        return true;
      }
      if (Operation != other.Operation) return false;
      return Equals(_unknownFields, other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override int GetHashCode() {
      int hash = 1;
      if (Operation.Length != 0) hash ^= Operation.GetHashCode();
      if (_unknownFields != null) {
        hash ^= _unknownFields.GetHashCode();
      }
      return hash;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override string ToString() {
      return pb::JsonFormatter.ToDiagnosticString(this);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void WriteTo(pb::CodedOutputStream output) {
      if (Operation.Length != 0) {
        output.WriteRawTag(10);
        output.WriteString(Operation);
      }
      if (_unknownFields != null) {
        _unknownFields.WriteTo(output);
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int CalculateSize() {
      int size = 0;
      if (Operation.Length != 0) {
        size += 1 + pb::CodedOutputStream.ComputeStringSize(Operation);
      }
      if (_unknownFields != null) {
        size += _unknownFields.CalculateSize();
      }
      return size;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(SavedConstant other) {
      if (other == null) {
        return;
      }
      if (other.Operation.Length != 0) {
        Operation = other.Operation;
      }
      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
            break;
          case 10: {
            Operation = input.ReadString();
            break;
          }
        }
      }
    }

  }

  /// <summary>
  /// Represents a Variable that is initialized by loading the contents from the
  /// checkpoint.
  /// </summary>
  public sealed partial class SavedVariable : pb::IMessage<SavedVariable> {
    private static readonly pb::MessageParser<SavedVariable> _parser = new pb::MessageParser<SavedVariable>(() => new SavedVariable());
    private pb::UnknownFieldSet _unknownFields;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pb::MessageParser<SavedVariable> Parser { get { return _parser; } }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pbr::MessageDescriptor Descriptor {
      get { return global::Tensorflow.SavedObjectGraphReflection.Descriptor.MessageTypes[9]; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    pbr::MessageDescriptor pb::IMessage.Descriptor {
      get { return Descriptor; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public SavedVariable() {
      OnConstruction();
    }

    partial void OnConstruction();

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public SavedVariable(SavedVariable other) : this() {
      dtype_ = other.dtype_;
      shape_ = other.shape_ != null ? other.shape_.Clone() : null;
      trainable_ = other.trainable_;
      synchronization_ = other.synchronization_;
      aggregation_ = other.aggregation_;
      name_ = other.name_;
      device_ = other.device_;
      experimentalDistributedVariableComponents_ = other.experimentalDistributedVariableComponents_.Clone();
      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public SavedVariable Clone() {
      return new SavedVariable(this);
    }

    /// <summary>Field number for the "dtype" field.</summary>
    public const int DtypeFieldNumber = 1;
    private global::Tensorflow.DataType dtype_ = global::Tensorflow.DataType.DtInvalid;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public global::Tensorflow.DataType Dtype {
      get { return dtype_; }
      set {
        dtype_ = value;
      }
    }

    /// <summary>Field number for the "shape" field.</summary>
    public const int ShapeFieldNumber = 2;
    private global::Tensorflow.TensorShapeProto shape_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public global::Tensorflow.TensorShapeProto Shape {
      get { return shape_; }
      set {
        shape_ = value;
      }
    }

    /// <summary>Field number for the "trainable" field.</summary>
    public const int TrainableFieldNumber = 3;
    private bool trainable_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool Trainable {
      get { return trainable_; }
      set {
        trainable_ = value;
      }
    }

    /// <summary>Field number for the "synchronization" field.</summary>
    public const int SynchronizationFieldNumber = 4;
    private global::Tensorflow.VariableSynchronization synchronization_ = global::Tensorflow.VariableSynchronization.Auto;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public global::Tensorflow.VariableSynchronization Synchronization {
      get { return synchronization_; }
      set {
        synchronization_ = value;
      }
    }

    /// <summary>Field number for the "aggregation" field.</summary>
    public const int AggregationFieldNumber = 5;
    private global::Tensorflow.VariableAggregation aggregation_ = global::Tensorflow.VariableAggregation.None;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public global::Tensorflow.VariableAggregation Aggregation {
      get { return aggregation_; }
      set {
        aggregation_ = value;
      }
    }

    /// <summary>Field number for the "name" field.</summary>
    public const int NameFieldNumber = 6;
    private string name_ = "";
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public string Name {
      get { return name_; }
      set {
        name_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
      }
    }

    /// <summary>Field number for the "device" field.</summary>
    public const int DeviceFieldNumber = 7;
    private string device_ = "";
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public string Device {
      get { return device_; }
      set {
        device_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
      }
    }

    /// <summary>Field number for the "experimental_distributed_variable_components" field.</summary>
    public const int ExperimentalDistributedVariableComponentsFieldNumber = 8;
    private static readonly pb::FieldCodec<global::Tensorflow.SavedVariable> _repeated_experimentalDistributedVariableComponents_codec
        = pb::FieldCodec.ForMessage(66, global::Tensorflow.SavedVariable.Parser);
    private readonly pbc::RepeatedField<global::Tensorflow.SavedVariable> experimentalDistributedVariableComponents_ = new pbc::RepeatedField<global::Tensorflow.SavedVariable>();
    /// <summary>
    /// List of component variables for a distributed variable.
    ///
    /// When this field is non-empty, the SavedVariable will be assumed
    /// to be a distributed variable defined by the components listed here.
    ///
    /// This is only supported by experimental loaders at the moment.
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<global::Tensorflow.SavedVariable> ExperimentalDistributedVariableComponents {
      get { return experimentalDistributedVariableComponents_; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override bool Equals(object other) {
      return Equals(other as SavedVariable);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool Equals(SavedVariable other) {
      if (ReferenceEquals(other, null)) {
        return false;
      }
      if (ReferenceEquals(other, this)) {
        return true;
      }
      if (Dtype != other.Dtype) return false;
      if (!object.Equals(Shape, other.Shape)) return false;
      if (Trainable != other.Trainable) return false;
      if (Synchronization != other.Synchronization) return false;
      if (Aggregation != other.Aggregation) return false;
      if (Name != other.Name) return false;
      if (Device != other.Device) return false;
      if(!experimentalDistributedVariableComponents_.Equals(other.experimentalDistributedVariableComponents_)) return false;
      return Equals(_unknownFields, other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override int GetHashCode() {
      int hash = 1;
      if (Dtype != global::Tensorflow.DataType.DtInvalid) hash ^= Dtype.GetHashCode();
      if (shape_ != null) hash ^= Shape.GetHashCode();
      if (Trainable != false) hash ^= Trainable.GetHashCode();
      if (Synchronization != global::Tensorflow.VariableSynchronization.Auto) hash ^= Synchronization.GetHashCode();
      if (Aggregation != global::Tensorflow.VariableAggregation.None) hash ^= Aggregation.GetHashCode();
      if (Name.Length != 0) hash ^= Name.GetHashCode();
      if (Device.Length != 0) hash ^= Device.GetHashCode();
      hash ^= experimentalDistributedVariableComponents_.GetHashCode();
      if (_unknownFields != null) {
        hash ^= _unknownFields.GetHashCode();
      }
      return hash;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override string ToString() {
      return pb::JsonFormatter.ToDiagnosticString(this);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void WriteTo(pb::CodedOutputStream output) {
      if (Dtype != global::Tensorflow.DataType.DtInvalid) {
        output.WriteRawTag(8);
        output.WriteEnum((int) Dtype);
      }
      if (shape_ != null) {
        output.WriteRawTag(18);
        output.WriteMessage(Shape);
      }
      if (Trainable != false) {
        output.WriteRawTag(24);
        output.WriteBool(Trainable);
      }
      if (Synchronization != global::Tensorflow.VariableSynchronization.Auto) {
        output.WriteRawTag(32);
        output.WriteEnum((int) Synchronization);
      }
      if (Aggregation != global::Tensorflow.VariableAggregation.None) {
        output.WriteRawTag(40);
        output.WriteEnum((int) Aggregation);
      }
      if (Name.Length != 0) {
        output.WriteRawTag(50);
        output.WriteString(Name);
      }
      if (Device.Length != 0) {
        output.WriteRawTag(58);
        output.WriteString(Device);
      }
      experimentalDistributedVariableComponents_.WriteTo(output, _repeated_experimentalDistributedVariableComponents_codec);
      if (_unknownFields != null) {
        _unknownFields.WriteTo(output);
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int CalculateSize() {
      int size = 0;
      if (Dtype != global::Tensorflow.DataType.DtInvalid) {
        size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) Dtype);
      }
      if (shape_ != null) {
        size += 1 + pb::CodedOutputStream.ComputeMessageSize(Shape);
      }
      if (Trainable != false) {
        size += 1 + 1;
      }
      if (Synchronization != global::Tensorflow.VariableSynchronization.Auto) {
        size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) Synchronization);
      }
      if (Aggregation != global::Tensorflow.VariableAggregation.None) {
        size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) Aggregation);
      }
      if (Name.Length != 0) {
        size += 1 + pb::CodedOutputStream.ComputeStringSize(Name);
      }
      if (Device.Length != 0) {
        size += 1 + pb::CodedOutputStream.ComputeStringSize(Device);
      }
      size += experimentalDistributedVariableComponents_.CalculateSize(_repeated_experimentalDistributedVariableComponents_codec);
      if (_unknownFields != null) {
        size += _unknownFields.CalculateSize();
      }
      return size;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(SavedVariable other) {
      if (other == null) {
        return;
      }
      if (other.Dtype != global::Tensorflow.DataType.DtInvalid) {
        Dtype = other.Dtype;
      }
      if (other.shape_ != null) {
        if (shape_ == null) {
          Shape = new global::Tensorflow.TensorShapeProto();
        }
        Shape.MergeFrom(other.Shape);
      }
      if (other.Trainable != false) {
        Trainable = other.Trainable;
      }
      if (other.Synchronization != global::Tensorflow.VariableSynchronization.Auto) {
        Synchronization = other.Synchronization;
      }
      if (other.Aggregation != global::Tensorflow.VariableAggregation.None) {
        Aggregation = other.Aggregation;
      }
      if (other.Name.Length != 0) {
        Name = other.Name;
      }
      if (other.Device.Length != 0) {
        Device = other.Device;
      }
      experimentalDistributedVariableComponents_.Add(other.experimentalDistributedVariableComponents_);
      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
            break;
          case 8: {
            Dtype = (global::Tensorflow.DataType) input.ReadEnum();
            break;
          }
          case 18: {
            if (shape_ == null) {
              Shape = new global::Tensorflow.TensorShapeProto();
            }
            input.ReadMessage(Shape);
            break;
          }
          case 24: {
            Trainable = input.ReadBool();
            break;
          }
          case 32: {
            Synchronization = (global::Tensorflow.VariableSynchronization) input.ReadEnum();
            break;
          }
          case 40: {
            Aggregation = (global::Tensorflow.VariableAggregation) input.ReadEnum();
            break;
          }
          case 50: {
            Name = input.ReadString();
            break;
          }
          case 58: {
            Device = input.ReadString();
            break;
          }
          case 66: {
            experimentalDistributedVariableComponents_.AddEntriesFrom(input, _repeated_experimentalDistributedVariableComponents_codec);
            break;
          }
        }
      }
    }

  }

  /// <summary>
  /// Represents `FunctionSpec` used in `Function`. This represents a
  /// function that has been wrapped as a TensorFlow `Function`.
  /// </summary>
  public sealed partial class FunctionSpec : pb::IMessage<FunctionSpec> {
    private static readonly pb::MessageParser<FunctionSpec> _parser = new pb::MessageParser<FunctionSpec>(() => new FunctionSpec());
    private pb::UnknownFieldSet _unknownFields;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pb::MessageParser<FunctionSpec> Parser { get { return _parser; } }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pbr::MessageDescriptor Descriptor {
      get { return global::Tensorflow.SavedObjectGraphReflection.Descriptor.MessageTypes[10]; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    pbr::MessageDescriptor pb::IMessage.Descriptor {
      get { return Descriptor; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public FunctionSpec() {
      OnConstruction();
    }

    partial void OnConstruction();

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public FunctionSpec(FunctionSpec other) : this() {
      fullargspec_ = other.fullargspec_ != null ? other.fullargspec_.Clone() : null;
      isMethod_ = other.isMethod_;
      inputSignature_ = other.inputSignature_ != null ? other.inputSignature_.Clone() : null;
      jitCompile_ = other.jitCompile_;
      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public FunctionSpec Clone() {
      return new FunctionSpec(this);
    }

    /// <summary>Field number for the "fullargspec" field.</summary>
    public const int FullargspecFieldNumber = 1;
    private global::Tensorflow.StructuredValue fullargspec_;
    /// <summary>
    /// Full arg spec from inspect.getfullargspec().
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public global::Tensorflow.StructuredValue Fullargspec {
      get { return fullargspec_; }
      set {
        fullargspec_ = value;
      }
    }

    /// <summary>Field number for the "is_method" field.</summary>
    public const int IsMethodFieldNumber = 2;
    private bool isMethod_;
    /// <summary>
    /// Whether this represents a class method.
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool IsMethod {
      get { return isMethod_; }
      set {
        isMethod_ = value;
      }
    }

    /// <summary>Field number for the "input_signature" field.</summary>
    public const int InputSignatureFieldNumber = 5;
    private global::Tensorflow.StructuredValue inputSignature_;
    /// <summary>
    /// The input signature, if specified.
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public global::Tensorflow.StructuredValue InputSignature {
      get { return inputSignature_; }
      set {
        inputSignature_ = value;
      }
    }

    /// <summary>Field number for the "jit_compile" field.</summary>
    public const int JitCompileFieldNumber = 6;
    private global::Tensorflow.FunctionSpec.Types.JitCompile jitCompile_ = global::Tensorflow.FunctionSpec.Types.JitCompile.Default;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public global::Tensorflow.FunctionSpec.Types.JitCompile JitCompile {
      get { return jitCompile_; }
      set {
        jitCompile_ = value;
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override bool Equals(object other) {
      return Equals(other as FunctionSpec);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool Equals(FunctionSpec other) {
      if (ReferenceEquals(other, null)) {
        return false;
      }
      if (ReferenceEquals(other, this)) {
        return true;
      }
      if (!object.Equals(Fullargspec, other.Fullargspec)) return false;
      if (IsMethod != other.IsMethod) return false;
      if (!object.Equals(InputSignature, other.InputSignature)) return false;
      if (JitCompile != other.JitCompile) return false;
      return Equals(_unknownFields, other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override int GetHashCode() {
      int hash = 1;
      if (fullargspec_ != null) hash ^= Fullargspec.GetHashCode();
      if (IsMethod != false) hash ^= IsMethod.GetHashCode();
      if (inputSignature_ != null) hash ^= InputSignature.GetHashCode();
      if (JitCompile != global::Tensorflow.FunctionSpec.Types.JitCompile.Default) hash ^= JitCompile.GetHashCode();
      if (_unknownFields != null) {
        hash ^= _unknownFields.GetHashCode();
      }
      return hash;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override string ToString() {
      return pb::JsonFormatter.ToDiagnosticString(this);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void WriteTo(pb::CodedOutputStream output) {
      if (fullargspec_ != null) {
        output.WriteRawTag(10);
        output.WriteMessage(Fullargspec);
      }
      if (IsMethod != false) {
        output.WriteRawTag(16);
        output.WriteBool(IsMethod);
      }
      if (inputSignature_ != null) {
        output.WriteRawTag(42);
        output.WriteMessage(InputSignature);
      }
      if (JitCompile != global::Tensorflow.FunctionSpec.Types.JitCompile.Default) {
        output.WriteRawTag(48);
        output.WriteEnum((int) JitCompile);
      }
      if (_unknownFields != null) {
        _unknownFields.WriteTo(output);
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int CalculateSize() {
      int size = 0;
      if (fullargspec_ != null) {
        size += 1 + pb::CodedOutputStream.ComputeMessageSize(Fullargspec);
      }
      if (IsMethod != false) {
        size += 1 + 1;
      }
      if (inputSignature_ != null) {
        size += 1 + pb::CodedOutputStream.ComputeMessageSize(InputSignature);
      }
      if (JitCompile != global::Tensorflow.FunctionSpec.Types.JitCompile.Default) {
        size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) JitCompile);
      }
      if (_unknownFields != null) {
        size += _unknownFields.CalculateSize();
      }
      return size;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(FunctionSpec other) {
      if (other == null) {
        return;
      }
      if (other.fullargspec_ != null) {
        if (fullargspec_ == null) {
          Fullargspec = new global::Tensorflow.StructuredValue();
        }
        Fullargspec.MergeFrom(other.Fullargspec);
      }
      if (other.IsMethod != false) {
        IsMethod = other.IsMethod;
      }
      if (other.inputSignature_ != null) {
        if (inputSignature_ == null) {
          InputSignature = new global::Tensorflow.StructuredValue();
        }
        InputSignature.MergeFrom(other.InputSignature);
      }
      if (other.JitCompile != global::Tensorflow.FunctionSpec.Types.JitCompile.Default) {
        JitCompile = other.JitCompile;
      }
      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
            break;
          case 10: {
            if (fullargspec_ == null) {
              Fullargspec = new global::Tensorflow.StructuredValue();
            }
            input.ReadMessage(Fullargspec);
            break;
          }
          case 16: {
            IsMethod = input.ReadBool();
            break;
          }
          case 42: {
            if (inputSignature_ == null) {
              InputSignature = new global::Tensorflow.StructuredValue();
            }
            input.ReadMessage(InputSignature);
            break;
          }
          case 48: {
            JitCompile = (global::Tensorflow.FunctionSpec.Types.JitCompile) input.ReadEnum();
            break;
          }
        }
      }
    }

    #region Nested types
    /// <summary>Container for nested types declared in the FunctionSpec message type.</summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static partial class Types {
      /// <summary>
      /// Whether the function should be compiled by XLA.
      ///
      /// The public interface to `tf.function` uses an optional boolean to
      /// represent three distinct states for this field.  Unfortunately, proto3
      /// removes the ability to explicitly check for the presence or absence of a
      /// field, so we instead map to an enum.
      ///
      /// See `tf.function` for details.
      /// </summary>
      public enum JitCompile {
        [pbr::OriginalName("DEFAULT")] Default = 0,
        [pbr::OriginalName("ON")] On = 1,
        [pbr::OriginalName("OFF")] Off = 2,
      }

    }
    #endregion

  }

  /// <summary>
  /// A SavedResource represents a TF object that holds state during its lifetime.
  /// An object of this type can have a reference to a:
  /// create_resource() and an initialize() function.
  /// </summary>
  public sealed partial class SavedResource : pb::IMessage<SavedResource> {
    private static readonly pb::MessageParser<SavedResource> _parser = new pb::MessageParser<SavedResource>(() => new SavedResource());
    private pb::UnknownFieldSet _unknownFields;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pb::MessageParser<SavedResource> Parser { get { return _parser; } }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pbr::MessageDescriptor Descriptor {
      get { return global::Tensorflow.SavedObjectGraphReflection.Descriptor.MessageTypes[11]; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    pbr::MessageDescriptor pb::IMessage.Descriptor {
      get { return Descriptor; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public SavedResource() {
      OnConstruction();
    }

    partial void OnConstruction();

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public SavedResource(SavedResource other) : this() {
      device_ = other.device_;
      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public SavedResource Clone() {
      return new SavedResource(this);
    }

    /// <summary>Field number for the "device" field.</summary>
    public const int DeviceFieldNumber = 1;
    private string device_ = "";
    /// <summary>
    /// A device specification indicating a required placement for the resource
    /// creation function, e.g. "CPU". An empty string allows the user to select a
    /// device.
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public string Device {
      get { return device_; }
      set {
        device_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override bool Equals(object other) {
      return Equals(other as SavedResource);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool Equals(SavedResource other) {
      if (ReferenceEquals(other, null)) {
        return false;
      }
      if (ReferenceEquals(other, this)) {
        return true;
      }
      if (Device != other.Device) return false;
      return Equals(_unknownFields, other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override int GetHashCode() {
      int hash = 1;
      if (Device.Length != 0) hash ^= Device.GetHashCode();
      if (_unknownFields != null) {
        hash ^= _unknownFields.GetHashCode();
      }
      return hash;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override string ToString() {
      return pb::JsonFormatter.ToDiagnosticString(this);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void WriteTo(pb::CodedOutputStream output) {
      if (Device.Length != 0) {
        output.WriteRawTag(10);
        output.WriteString(Device);
      }
      if (_unknownFields != null) {
        _unknownFields.WriteTo(output);
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int CalculateSize() {
      int size = 0;
      if (Device.Length != 0) {
        size += 1 + pb::CodedOutputStream.ComputeStringSize(Device);
      }
      if (_unknownFields != null) {
        size += _unknownFields.CalculateSize();
      }
      return size;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(SavedResource other) {
      if (other == null) {
        return;
      }
      if (other.Device.Length != 0) {
        Device = other.Device;
      }
      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
            break;
          case 10: {
            Device = input.ReadString();
            break;
          }
        }
      }
    }

  }

  public sealed partial class SaveableObject : pb::IMessage<SaveableObject> {
    private static readonly pb::MessageParser<SaveableObject> _parser = new pb::MessageParser<SaveableObject>(() => new SaveableObject());
    private pb::UnknownFieldSet _unknownFields;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pb::MessageParser<SaveableObject> Parser { get { return _parser; } }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pbr::MessageDescriptor Descriptor {
      get { return global::Tensorflow.SavedObjectGraphReflection.Descriptor.MessageTypes[12]; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    pbr::MessageDescriptor pb::IMessage.Descriptor {
      get { return Descriptor; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public SaveableObject() {
      OnConstruction();
    }

    partial void OnConstruction();

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public SaveableObject(SaveableObject other) : this() {
      saveFunction_ = other.saveFunction_;
      restoreFunction_ = other.restoreFunction_;
      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public SaveableObject Clone() {
      return new SaveableObject(this);
    }

    /// <summary>Field number for the "save_function" field.</summary>
    public const int SaveFunctionFieldNumber = 2;
    private int saveFunction_;
    /// <summary>
    /// Node ids of concrete functions for saving and loading from a checkpoint.
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int SaveFunction {
      get { return saveFunction_; }
      set {
        saveFunction_ = value;
      }
    }

    /// <summary>Field number for the "restore_function" field.</summary>
    public const int RestoreFunctionFieldNumber = 3;
    private int restoreFunction_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int RestoreFunction {
      get { return restoreFunction_; }
      set {
        restoreFunction_ = value;
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override bool Equals(object other) {
      return Equals(other as SaveableObject);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool Equals(SaveableObject other) {
      if (ReferenceEquals(other, null)) {
        return false;
      }
      if (ReferenceEquals(other, this)) {
        return true;
      }
      if (SaveFunction != other.SaveFunction) return false;
      if (RestoreFunction != other.RestoreFunction) return false;
      return Equals(_unknownFields, other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override int GetHashCode() {
      int hash = 1;
      if (SaveFunction != 0) hash ^= SaveFunction.GetHashCode();
      if (RestoreFunction != 0) hash ^= RestoreFunction.GetHashCode();
      if (_unknownFields != null) {
        hash ^= _unknownFields.GetHashCode();
      }
      return hash;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override string ToString() {
      return pb::JsonFormatter.ToDiagnosticString(this);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void WriteTo(pb::CodedOutputStream output) {
      if (SaveFunction != 0) {
        output.WriteRawTag(16);
        output.WriteInt32(SaveFunction);
      }
      if (RestoreFunction != 0) {
        output.WriteRawTag(24);
        output.WriteInt32(RestoreFunction);
      }
      if (_unknownFields != null) {
        _unknownFields.WriteTo(output);
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int CalculateSize() {
      int size = 0;
      if (SaveFunction != 0) {
        size += 1 + pb::CodedOutputStream.ComputeInt32Size(SaveFunction);
      }
      if (RestoreFunction != 0) {
        size += 1 + pb::CodedOutputStream.ComputeInt32Size(RestoreFunction);
      }
      if (_unknownFields != null) {
        size += _unknownFields.CalculateSize();
      }
      return size;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(SaveableObject other) {
      if (other == null) {
        return;
      }
      if (other.SaveFunction != 0) {
        SaveFunction = other.SaveFunction;
      }
      if (other.RestoreFunction != 0) {
        RestoreFunction = other.RestoreFunction;
      }
      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
            break;
          case 16: {
            SaveFunction = input.ReadInt32();
            break;
          }
          case 24: {
            RestoreFunction = input.ReadInt32();
            break;
          }
        }
      }
    }

  }

  #endregion

}

#endregion Designer generated code