// <auto-generated>
//     Generated by the protocol buffer compiler.  DO NOT EDIT!
//     source: tensorflow/core/framework/cost_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/framework/cost_graph.proto</summary>
  public static partial class CostGraphReflection {

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

    static CostGraphReflection() {
      byte[] descriptorData = global::System.Convert.FromBase64String(
          string.Concat(
            "Cip0ZW5zb3JmbG93L2NvcmUvZnJhbWV3b3JrL2Nvc3RfZ3JhcGgucHJvdG8S",
            "CnRlbnNvcmZsb3caLHRlbnNvcmZsb3cvY29yZS9mcmFtZXdvcmsvdGVuc29y",
            "X3NoYXBlLnByb3RvGiV0ZW5zb3JmbG93L2NvcmUvZnJhbWV3b3JrL3R5cGVz",
            "LnByb3RvIuAFCgxDb3N0R3JhcGhEZWYSKwoEbm9kZRgBIAMoCzIdLnRlbnNv",
            "cmZsb3cuQ29zdEdyYXBoRGVmLk5vZGUaogUKBE5vZGUSDAoEbmFtZRgBIAEo",
            "CRIOCgZkZXZpY2UYAiABKAkSCgoCaWQYAyABKAUSOwoKaW5wdXRfaW5mbxgE",
            "IAMoCzInLnRlbnNvcmZsb3cuQ29zdEdyYXBoRGVmLk5vZGUuSW5wdXRJbmZv",
            "Ej0KC291dHB1dF9pbmZvGAUgAygLMigudGVuc29yZmxvdy5Db3N0R3JhcGhE",
            "ZWYuTm9kZS5PdXRwdXRJbmZvEh0KFXRlbXBvcmFyeV9tZW1vcnlfc2l6ZRgG",
            "IAEoAxIeChZwZXJzaXN0ZW50X21lbW9yeV9zaXplGAwgASgDEiEKFWhvc3Rf",
            "dGVtcF9tZW1vcnlfc2l6ZRgKIAEoA0ICGAESIwoXZGV2aWNlX3RlbXBfbWVt",
            "b3J5X3NpemUYCyABKANCAhgBEikKHWRldmljZV9wZXJzaXN0ZW50X21lbW9y",
            "eV9zaXplGBAgASgDQgIYARIUCgxjb21wdXRlX2Nvc3QYCSABKAMSFAoMY29t",
            "cHV0ZV90aW1lGA4gASgDEhMKC21lbW9yeV90aW1lGA8gASgDEhAKCGlzX2Zp",
            "bmFsGAcgASgIEhUKDWNvbnRyb2xfaW5wdXQYCCADKAUSEgoKaW5hY2N1cmF0",
            "ZRgRIAEoCBo7CglJbnB1dEluZm8SFgoOcHJlY2VkaW5nX25vZGUYASABKAUS",
            "FgoOcHJlY2VkaW5nX3BvcnQYAiABKAUahgEKCk91dHB1dEluZm8SDAoEc2l6",
            "ZRgBIAEoAxIYChBhbGlhc19pbnB1dF9wb3J0GAIgASgDEisKBXNoYXBlGAMg",
            "ASgLMhwudGVuc29yZmxvdy5UZW5zb3JTaGFwZVByb3RvEiMKBWR0eXBlGAQg",
            "ASgOMhQudGVuc29yZmxvdy5EYXRhVHlwZUJvChhvcmcudGVuc29yZmxvdy5m",
            "cmFtZXdvcmtCD0Nvc3RHcmFwaFByb3Rvc1ABWj1naXRodWIuY29tL3RlbnNv",
            "cmZsb3cvdGVuc29yZmxvdy90ZW5zb3JmbG93L2dvL2NvcmUvZnJhbWV3b3Jr",
            "+AEBYgZwcm90bzM="));
      descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,
          new pbr::FileDescriptor[] { global::Tensorflow.TensorShapeReflection.Descriptor, global::Tensorflow.TypesReflection.Descriptor, },
          new pbr::GeneratedClrTypeInfo(null, new pbr::GeneratedClrTypeInfo[] {
            new pbr::GeneratedClrTypeInfo(typeof(global::Tensorflow.CostGraphDef), global::Tensorflow.CostGraphDef.Parser, new[]{ "Node" }, null, null, new pbr::GeneratedClrTypeInfo[] { new pbr::GeneratedClrTypeInfo(typeof(global::Tensorflow.CostGraphDef.Types.Node), global::Tensorflow.CostGraphDef.Types.Node.Parser, new[]{ "Name", "Device", "Id", "InputInfo", "OutputInfo", "TemporaryMemorySize", "PersistentMemorySize", "HostTempMemorySize", "DeviceTempMemorySize", "DevicePersistentMemorySize", "ComputeCost", "ComputeTime", "MemoryTime", "IsFinal", "ControlInput", "Inaccurate" }, null, null, new pbr::GeneratedClrTypeInfo[] { new pbr::GeneratedClrTypeInfo(typeof(global::Tensorflow.CostGraphDef.Types.Node.Types.InputInfo), global::Tensorflow.CostGraphDef.Types.Node.Types.InputInfo.Parser, new[]{ "PrecedingNode", "PrecedingPort" }, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(global::Tensorflow.CostGraphDef.Types.Node.Types.OutputInfo), global::Tensorflow.CostGraphDef.Types.Node.Types.OutputInfo.Parser, new[]{ "Size", "AliasInputPort", "Shape", "Dtype" }, null, null, null)})})
          }));
    }
    #endregion

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

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

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

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

    partial void OnConstruction();

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

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

    /// <summary>Field number for the "node" field.</summary>
    public const int NodeFieldNumber = 1;
    private static readonly pb::FieldCodec<global::Tensorflow.CostGraphDef.Types.Node> _repeated_node_codec
        = pb::FieldCodec.ForMessage(10, global::Tensorflow.CostGraphDef.Types.Node.Parser);
    private readonly pbc::RepeatedField<global::Tensorflow.CostGraphDef.Types.Node> node_ = new pbc::RepeatedField<global::Tensorflow.CostGraphDef.Types.Node>();
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<global::Tensorflow.CostGraphDef.Types.Node> Node {
      get { return node_; }
    }

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

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

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override int GetHashCode() {
      int hash = 1;
      hash ^= node_.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) {
      node_.WriteTo(output, _repeated_node_codec);
      if (_unknownFields != null) {
        _unknownFields.WriteTo(output);
      }
    }

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

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(CostGraphDef other) {
      if (other == null) {
        return;
      }
      node_.Add(other.node_);
      _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: {
            node_.AddEntriesFrom(input, _repeated_node_codec);
            break;
          }
        }
      }
    }

    #region Nested types
    /// <summary>Container for nested types declared in the CostGraphDef message type.</summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static partial class Types {
      public sealed partial class Node : pb::IMessage<Node> {
        private static readonly pb::MessageParser<Node> _parser = new pb::MessageParser<Node>(() => new Node());
        private pb::UnknownFieldSet _unknownFields;
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public static pb::MessageParser<Node> Parser { get { return _parser; } }

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

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

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

        partial void OnConstruction();

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public Node(Node other) : this() {
          name_ = other.name_;
          device_ = other.device_;
          id_ = other.id_;
          inputInfo_ = other.inputInfo_.Clone();
          outputInfo_ = other.outputInfo_.Clone();
          temporaryMemorySize_ = other.temporaryMemorySize_;
          persistentMemorySize_ = other.persistentMemorySize_;
          hostTempMemorySize_ = other.hostTempMemorySize_;
          deviceTempMemorySize_ = other.deviceTempMemorySize_;
          devicePersistentMemorySize_ = other.devicePersistentMemorySize_;
          computeCost_ = other.computeCost_;
          computeTime_ = other.computeTime_;
          memoryTime_ = other.memoryTime_;
          isFinal_ = other.isFinal_;
          controlInput_ = other.controlInput_.Clone();
          inaccurate_ = other.inaccurate_;
          _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
        }

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

        /// <summary>Field number for the "name" field.</summary>
        public const int NameFieldNumber = 1;
        private string name_ = "";
        /// <summary>
        /// The name of the node. Names are globally unique.
        /// </summary>
        [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 = 2;
        private string device_ = "";
        /// <summary>
        /// The device of the node. Can be empty if the node is mapped to the
        /// default partition or partitioning hasn't been run yet.
        /// </summary>
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public string Device {
          get { return device_; }
          set {
            device_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
          }
        }

        /// <summary>Field number for the "id" field.</summary>
        public const int IdFieldNumber = 3;
        private int id_;
        /// <summary>
        /// The id of the node. Node ids are only unique inside a partition.
        /// </summary>
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public int Id {
          get { return id_; }
          set {
            id_ = value;
          }
        }

        /// <summary>Field number for the "input_info" field.</summary>
        public const int InputInfoFieldNumber = 4;
        private static readonly pb::FieldCodec<global::Tensorflow.CostGraphDef.Types.Node.Types.InputInfo> _repeated_inputInfo_codec
            = pb::FieldCodec.ForMessage(34, global::Tensorflow.CostGraphDef.Types.Node.Types.InputInfo.Parser);
        private readonly pbc::RepeatedField<global::Tensorflow.CostGraphDef.Types.Node.Types.InputInfo> inputInfo_ = new pbc::RepeatedField<global::Tensorflow.CostGraphDef.Types.Node.Types.InputInfo>();
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public pbc::RepeatedField<global::Tensorflow.CostGraphDef.Types.Node.Types.InputInfo> InputInfo {
          get { return inputInfo_; }
        }

        /// <summary>Field number for the "output_info" field.</summary>
        public const int OutputInfoFieldNumber = 5;
        private static readonly pb::FieldCodec<global::Tensorflow.CostGraphDef.Types.Node.Types.OutputInfo> _repeated_outputInfo_codec
            = pb::FieldCodec.ForMessage(42, global::Tensorflow.CostGraphDef.Types.Node.Types.OutputInfo.Parser);
        private readonly pbc::RepeatedField<global::Tensorflow.CostGraphDef.Types.Node.Types.OutputInfo> outputInfo_ = new pbc::RepeatedField<global::Tensorflow.CostGraphDef.Types.Node.Types.OutputInfo>();
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public pbc::RepeatedField<global::Tensorflow.CostGraphDef.Types.Node.Types.OutputInfo> OutputInfo {
          get { return outputInfo_; }
        }

        /// <summary>Field number for the "temporary_memory_size" field.</summary>
        public const int TemporaryMemorySizeFieldNumber = 6;
        private long temporaryMemorySize_;
        /// <summary>
        /// Temporary memory used by this node.
        /// </summary>
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public long TemporaryMemorySize {
          get { return temporaryMemorySize_; }
          set {
            temporaryMemorySize_ = value;
          }
        }

        /// <summary>Field number for the "persistent_memory_size" field.</summary>
        public const int PersistentMemorySizeFieldNumber = 12;
        private long persistentMemorySize_;
        /// <summary>
        /// Persistent memory used by this node.
        /// </summary>
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public long PersistentMemorySize {
          get { return persistentMemorySize_; }
          set {
            persistentMemorySize_ = value;
          }
        }

        /// <summary>Field number for the "host_temp_memory_size" field.</summary>
        public const int HostTempMemorySizeFieldNumber = 10;
        private long hostTempMemorySize_;
        [global::System.ObsoleteAttribute]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public long HostTempMemorySize {
          get { return hostTempMemorySize_; }
          set {
            hostTempMemorySize_ = value;
          }
        }

        /// <summary>Field number for the "device_temp_memory_size" field.</summary>
        public const int DeviceTempMemorySizeFieldNumber = 11;
        private long deviceTempMemorySize_;
        [global::System.ObsoleteAttribute]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public long DeviceTempMemorySize {
          get { return deviceTempMemorySize_; }
          set {
            deviceTempMemorySize_ = value;
          }
        }

        /// <summary>Field number for the "device_persistent_memory_size" field.</summary>
        public const int DevicePersistentMemorySizeFieldNumber = 16;
        private long devicePersistentMemorySize_;
        [global::System.ObsoleteAttribute]
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public long DevicePersistentMemorySize {
          get { return devicePersistentMemorySize_; }
          set {
            devicePersistentMemorySize_ = value;
          }
        }

        /// <summary>Field number for the "compute_cost" field.</summary>
        public const int ComputeCostFieldNumber = 9;
        private long computeCost_;
        /// <summary>
        /// Estimate of the computational cost of this node, in microseconds.
        /// </summary>
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public long ComputeCost {
          get { return computeCost_; }
          set {
            computeCost_ = value;
          }
        }

        /// <summary>Field number for the "compute_time" field.</summary>
        public const int ComputeTimeFieldNumber = 14;
        private long computeTime_;
        /// <summary>
        /// Analytical estimate of the computational cost of this node, in
        /// microseconds.
        /// </summary>
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public long ComputeTime {
          get { return computeTime_; }
          set {
            computeTime_ = value;
          }
        }

        /// <summary>Field number for the "memory_time" field.</summary>
        public const int MemoryTimeFieldNumber = 15;
        private long memoryTime_;
        /// <summary>
        /// Analytical estimate of the memory access cost of this node, in
        /// microseconds.
        /// </summary>
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public long MemoryTime {
          get { return memoryTime_; }
          set {
            memoryTime_ = value;
          }
        }

        /// <summary>Field number for the "is_final" field.</summary>
        public const int IsFinalFieldNumber = 7;
        private bool isFinal_;
        /// <summary>
        /// If true, the output is permanent: it can't be discarded, because this
        /// node is part of the "final output". Nodes may depend on final nodes.
        /// </summary>
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public bool IsFinal {
          get { return isFinal_; }
          set {
            isFinal_ = value;
          }
        }

        /// <summary>Field number for the "control_input" field.</summary>
        public const int ControlInputFieldNumber = 8;
        private static readonly pb::FieldCodec<int> _repeated_controlInput_codec
            = pb::FieldCodec.ForInt32(66);
        private readonly pbc::RepeatedField<int> controlInput_ = new pbc::RepeatedField<int>();
        /// <summary>
        /// Ids of the control inputs for this node.
        /// </summary>
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public pbc::RepeatedField<int> ControlInput {
          get { return controlInput_; }
        }

        /// <summary>Field number for the "inaccurate" field.</summary>
        public const int InaccurateFieldNumber = 17;
        private bool inaccurate_;
        /// <summary>
        /// Are the costs inaccurate?
        /// </summary>
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public bool Inaccurate {
          get { return inaccurate_; }
          set {
            inaccurate_ = value;
          }
        }

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

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public bool Equals(Node other) {
          if (ReferenceEquals(other, null)) {
            return false;
          }
          if (ReferenceEquals(other, this)) {
            return true;
          }
          if (Name != other.Name) return false;
          if (Device != other.Device) return false;
          if (Id != other.Id) return false;
          if(!inputInfo_.Equals(other.inputInfo_)) return false;
          if(!outputInfo_.Equals(other.outputInfo_)) return false;
          if (TemporaryMemorySize != other.TemporaryMemorySize) return false;
          if (PersistentMemorySize != other.PersistentMemorySize) return false;
          if (HostTempMemorySize != other.HostTempMemorySize) return false;
          if (DeviceTempMemorySize != other.DeviceTempMemorySize) return false;
          if (DevicePersistentMemorySize != other.DevicePersistentMemorySize) return false;
          if (ComputeCost != other.ComputeCost) return false;
          if (ComputeTime != other.ComputeTime) return false;
          if (MemoryTime != other.MemoryTime) return false;
          if (IsFinal != other.IsFinal) return false;
          if(!controlInput_.Equals(other.controlInput_)) return false;
          if (Inaccurate != other.Inaccurate) 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 (Device.Length != 0) hash ^= Device.GetHashCode();
          if (Id != 0) hash ^= Id.GetHashCode();
          hash ^= inputInfo_.GetHashCode();
          hash ^= outputInfo_.GetHashCode();
          if (TemporaryMemorySize != 0L) hash ^= TemporaryMemorySize.GetHashCode();
          if (PersistentMemorySize != 0L) hash ^= PersistentMemorySize.GetHashCode();
          if (HostTempMemorySize != 0L) hash ^= HostTempMemorySize.GetHashCode();
          if (DeviceTempMemorySize != 0L) hash ^= DeviceTempMemorySize.GetHashCode();
          if (DevicePersistentMemorySize != 0L) hash ^= DevicePersistentMemorySize.GetHashCode();
          if (ComputeCost != 0L) hash ^= ComputeCost.GetHashCode();
          if (ComputeTime != 0L) hash ^= ComputeTime.GetHashCode();
          if (MemoryTime != 0L) hash ^= MemoryTime.GetHashCode();
          if (IsFinal != false) hash ^= IsFinal.GetHashCode();
          hash ^= controlInput_.GetHashCode();
          if (Inaccurate != false) hash ^= Inaccurate.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 (Device.Length != 0) {
            output.WriteRawTag(18);
            output.WriteString(Device);
          }
          if (Id != 0) {
            output.WriteRawTag(24);
            output.WriteInt32(Id);
          }
          inputInfo_.WriteTo(output, _repeated_inputInfo_codec);
          outputInfo_.WriteTo(output, _repeated_outputInfo_codec);
          if (TemporaryMemorySize != 0L) {
            output.WriteRawTag(48);
            output.WriteInt64(TemporaryMemorySize);
          }
          if (IsFinal != false) {
            output.WriteRawTag(56);
            output.WriteBool(IsFinal);
          }
          controlInput_.WriteTo(output, _repeated_controlInput_codec);
          if (ComputeCost != 0L) {
            output.WriteRawTag(72);
            output.WriteInt64(ComputeCost);
          }
          if (HostTempMemorySize != 0L) {
            output.WriteRawTag(80);
            output.WriteInt64(HostTempMemorySize);
          }
          if (DeviceTempMemorySize != 0L) {
            output.WriteRawTag(88);
            output.WriteInt64(DeviceTempMemorySize);
          }
          if (PersistentMemorySize != 0L) {
            output.WriteRawTag(96);
            output.WriteInt64(PersistentMemorySize);
          }
          if (ComputeTime != 0L) {
            output.WriteRawTag(112);
            output.WriteInt64(ComputeTime);
          }
          if (MemoryTime != 0L) {
            output.WriteRawTag(120);
            output.WriteInt64(MemoryTime);
          }
          if (DevicePersistentMemorySize != 0L) {
            output.WriteRawTag(128, 1);
            output.WriteInt64(DevicePersistentMemorySize);
          }
          if (Inaccurate != false) {
            output.WriteRawTag(136, 1);
            output.WriteBool(Inaccurate);
          }
          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 (Device.Length != 0) {
            size += 1 + pb::CodedOutputStream.ComputeStringSize(Device);
          }
          if (Id != 0) {
            size += 1 + pb::CodedOutputStream.ComputeInt32Size(Id);
          }
          size += inputInfo_.CalculateSize(_repeated_inputInfo_codec);
          size += outputInfo_.CalculateSize(_repeated_outputInfo_codec);
          if (TemporaryMemorySize != 0L) {
            size += 1 + pb::CodedOutputStream.ComputeInt64Size(TemporaryMemorySize);
          }
          if (PersistentMemorySize != 0L) {
            size += 1 + pb::CodedOutputStream.ComputeInt64Size(PersistentMemorySize);
          }
          if (HostTempMemorySize != 0L) {
            size += 1 + pb::CodedOutputStream.ComputeInt64Size(HostTempMemorySize);
          }
          if (DeviceTempMemorySize != 0L) {
            size += 1 + pb::CodedOutputStream.ComputeInt64Size(DeviceTempMemorySize);
          }
          if (DevicePersistentMemorySize != 0L) {
            size += 2 + pb::CodedOutputStream.ComputeInt64Size(DevicePersistentMemorySize);
          }
          if (ComputeCost != 0L) {
            size += 1 + pb::CodedOutputStream.ComputeInt64Size(ComputeCost);
          }
          if (ComputeTime != 0L) {
            size += 1 + pb::CodedOutputStream.ComputeInt64Size(ComputeTime);
          }
          if (MemoryTime != 0L) {
            size += 1 + pb::CodedOutputStream.ComputeInt64Size(MemoryTime);
          }
          if (IsFinal != false) {
            size += 1 + 1;
          }
          size += controlInput_.CalculateSize(_repeated_controlInput_codec);
          if (Inaccurate != false) {
            size += 2 + 1;
          }
          if (_unknownFields != null) {
            size += _unknownFields.CalculateSize();
          }
          return size;
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public void MergeFrom(Node other) {
          if (other == null) {
            return;
          }
          if (other.Name.Length != 0) {
            Name = other.Name;
          }
          if (other.Device.Length != 0) {
            Device = other.Device;
          }
          if (other.Id != 0) {
            Id = other.Id;
          }
          inputInfo_.Add(other.inputInfo_);
          outputInfo_.Add(other.outputInfo_);
          if (other.TemporaryMemorySize != 0L) {
            TemporaryMemorySize = other.TemporaryMemorySize;
          }
          if (other.PersistentMemorySize != 0L) {
            PersistentMemorySize = other.PersistentMemorySize;
          }
          if (other.HostTempMemorySize != 0L) {
            HostTempMemorySize = other.HostTempMemorySize;
          }
          if (other.DeviceTempMemorySize != 0L) {
            DeviceTempMemorySize = other.DeviceTempMemorySize;
          }
          if (other.DevicePersistentMemorySize != 0L) {
            DevicePersistentMemorySize = other.DevicePersistentMemorySize;
          }
          if (other.ComputeCost != 0L) {
            ComputeCost = other.ComputeCost;
          }
          if (other.ComputeTime != 0L) {
            ComputeTime = other.ComputeTime;
          }
          if (other.MemoryTime != 0L) {
            MemoryTime = other.MemoryTime;
          }
          if (other.IsFinal != false) {
            IsFinal = other.IsFinal;
          }
          controlInput_.Add(other.controlInput_);
          if (other.Inaccurate != false) {
            Inaccurate = other.Inaccurate;
          }
          _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: {
                Device = input.ReadString();
                break;
              }
              case 24: {
                Id = input.ReadInt32();
                break;
              }
              case 34: {
                inputInfo_.AddEntriesFrom(input, _repeated_inputInfo_codec);
                break;
              }
              case 42: {
                outputInfo_.AddEntriesFrom(input, _repeated_outputInfo_codec);
                break;
              }
              case 48: {
                TemporaryMemorySize = input.ReadInt64();
                break;
              }
              case 56: {
                IsFinal = input.ReadBool();
                break;
              }
              case 66:
              case 64: {
                controlInput_.AddEntriesFrom(input, _repeated_controlInput_codec);
                break;
              }
              case 72: {
                ComputeCost = input.ReadInt64();
                break;
              }
              case 80: {
                HostTempMemorySize = input.ReadInt64();
                break;
              }
              case 88: {
                DeviceTempMemorySize = input.ReadInt64();
                break;
              }
              case 96: {
                PersistentMemorySize = input.ReadInt64();
                break;
              }
              case 112: {
                ComputeTime = input.ReadInt64();
                break;
              }
              case 120: {
                MemoryTime = input.ReadInt64();
                break;
              }
              case 128: {
                DevicePersistentMemorySize = input.ReadInt64();
                break;
              }
              case 136: {
                Inaccurate = input.ReadBool();
                break;
              }
            }
          }
        }

        #region Nested types
        /// <summary>Container for nested types declared in the Node message type.</summary>
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public static partial class Types {
          /// <summary>
          /// Inputs of this node. They must be executed before this node can be
          /// executed. An input is a particular output of another node, specified
          /// by the node id and the output index.
          /// </summary>
          public sealed partial class InputInfo : pb::IMessage<InputInfo> {
            private static readonly pb::MessageParser<InputInfo> _parser = new pb::MessageParser<InputInfo>(() => new InputInfo());
            private pb::UnknownFieldSet _unknownFields;
            [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
            public static pb::MessageParser<InputInfo> Parser { get { return _parser; } }

            [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
            public static pbr::MessageDescriptor Descriptor {
              get { return global::Tensorflow.CostGraphDef.Types.Node.Descriptor.NestedTypes[0]; }
            }

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

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

            partial void OnConstruction();

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

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

            /// <summary>Field number for the "preceding_node" field.</summary>
            public const int PrecedingNodeFieldNumber = 1;
            private int precedingNode_;
            [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
            public int PrecedingNode {
              get { return precedingNode_; }
              set {
                precedingNode_ = value;
              }
            }

            /// <summary>Field number for the "preceding_port" field.</summary>
            public const int PrecedingPortFieldNumber = 2;
            private int precedingPort_;
            [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
            public int PrecedingPort {
              get { return precedingPort_; }
              set {
                precedingPort_ = value;
              }
            }

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

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

            [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
            public override int GetHashCode() {
              int hash = 1;
              if (PrecedingNode != 0) hash ^= PrecedingNode.GetHashCode();
              if (PrecedingPort != 0) hash ^= PrecedingPort.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 (PrecedingNode != 0) {
                output.WriteRawTag(8);
                output.WriteInt32(PrecedingNode);
              }
              if (PrecedingPort != 0) {
                output.WriteRawTag(16);
                output.WriteInt32(PrecedingPort);
              }
              if (_unknownFields != null) {
                _unknownFields.WriteTo(output);
              }
            }

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

            [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
            public void MergeFrom(InputInfo other) {
              if (other == null) {
                return;
              }
              if (other.PrecedingNode != 0) {
                PrecedingNode = other.PrecedingNode;
              }
              if (other.PrecedingPort != 0) {
                PrecedingPort = other.PrecedingPort;
              }
              _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: {
                    PrecedingNode = input.ReadInt32();
                    break;
                  }
                  case 16: {
                    PrecedingPort = input.ReadInt32();
                    break;
                  }
                }
              }
            }

          }

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

            [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
            public static pbr::MessageDescriptor Descriptor {
              get { return global::Tensorflow.CostGraphDef.Types.Node.Descriptor.NestedTypes[1]; }
            }

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

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

            partial void OnConstruction();

            [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
            public OutputInfo(OutputInfo other) : this() {
              size_ = other.size_;
              aliasInputPort_ = other.aliasInputPort_;
              shape_ = other.shape_ != null ? other.shape_.Clone() : null;
              dtype_ = other.dtype_;
              _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
            }

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

            /// <summary>Field number for the "size" field.</summary>
            public const int SizeFieldNumber = 1;
            private long size_;
            [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
            public long Size {
              get { return size_; }
              set {
                size_ = value;
              }
            }

            /// <summary>Field number for the "alias_input_port" field.</summary>
            public const int AliasInputPortFieldNumber = 2;
            private long aliasInputPort_;
            /// <summary>
            /// If >= 0, the output is an alias of an input. Note that an alias input
            /// may itself be an alias. The algorithm will therefore need to follow
            /// those pointers.
            /// </summary>
            [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
            public long AliasInputPort {
              get { return aliasInputPort_; }
              set {
                aliasInputPort_ = value;
              }
            }

            /// <summary>Field number for the "shape" field.</summary>
            public const int ShapeFieldNumber = 3;
            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 "dtype" field.</summary>
            public const int DtypeFieldNumber = 4;
            private global::Tensorflow.DataType dtype_ = 0;
            [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
            public global::Tensorflow.DataType Dtype {
              get { return dtype_; }
              set {
                dtype_ = value;
              }
            }

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

            [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
            public bool Equals(OutputInfo other) {
              if (ReferenceEquals(other, null)) {
                return false;
              }
              if (ReferenceEquals(other, this)) {
                return true;
              }
              if (Size != other.Size) return false;
              if (AliasInputPort != other.AliasInputPort) return false;
              if (!object.Equals(Shape, other.Shape)) return false;
              if (Dtype != other.Dtype) return false;
              return Equals(_unknownFields, other._unknownFields);
            }

            [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
            public override int GetHashCode() {
              int hash = 1;
              if (Size != 0L) hash ^= Size.GetHashCode();
              if (AliasInputPort != 0L) hash ^= AliasInputPort.GetHashCode();
              if (shape_ != null) hash ^= Shape.GetHashCode();
              if (Dtype != 0) hash ^= Dtype.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 (Size != 0L) {
                output.WriteRawTag(8);
                output.WriteInt64(Size);
              }
              if (AliasInputPort != 0L) {
                output.WriteRawTag(16);
                output.WriteInt64(AliasInputPort);
              }
              if (shape_ != null) {
                output.WriteRawTag(26);
                output.WriteMessage(Shape);
              }
              if (Dtype != 0) {
                output.WriteRawTag(32);
                output.WriteEnum((int) Dtype);
              }
              if (_unknownFields != null) {
                _unknownFields.WriteTo(output);
              }
            }

            [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
            public int CalculateSize() {
              int size = 0;
              if (Size != 0L) {
                size += 1 + pb::CodedOutputStream.ComputeInt64Size(Size);
              }
              if (AliasInputPort != 0L) {
                size += 1 + pb::CodedOutputStream.ComputeInt64Size(AliasInputPort);
              }
              if (shape_ != null) {
                size += 1 + pb::CodedOutputStream.ComputeMessageSize(Shape);
              }
              if (Dtype != 0) {
                size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) Dtype);
              }
              if (_unknownFields != null) {
                size += _unknownFields.CalculateSize();
              }
              return size;
            }

            [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
            public void MergeFrom(OutputInfo other) {
              if (other == null) {
                return;
              }
              if (other.Size != 0L) {
                Size = other.Size;
              }
              if (other.AliasInputPort != 0L) {
                AliasInputPort = other.AliasInputPort;
              }
              if (other.shape_ != null) {
                if (shape_ == null) {
                  shape_ = new global::Tensorflow.TensorShapeProto();
                }
                Shape.MergeFrom(other.Shape);
              }
              if (other.Dtype != 0) {
                Dtype = other.Dtype;
              }
              _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: {
                    Size = input.ReadInt64();
                    break;
                  }
                  case 16: {
                    AliasInputPort = input.ReadInt64();
                    break;
                  }
                  case 26: {
                    if (shape_ == null) {
                      shape_ = new global::Tensorflow.TensorShapeProto();
                    }
                    input.ReadMessage(shape_);
                    break;
                  }
                  case 32: {
                    dtype_ = (global::Tensorflow.DataType) input.ReadEnum();
                    break;
                  }
                }
              }
            }

          }

        }
        #endregion

      }

    }
    #endregion

  }

  #endregion

}

#endregion Designer generated code
