scisharp
/
TensorFlow.NET
Not watched
1
0
Fork 0
Code
Releases 21 Wiki evaluate Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain HPC
You can not select more than 25 topics Topics must start with a chinese character,a letter or number, can include dashes ('-') and can be up to 35 characters long.
Tree: 31f79e8a5f
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '31f79e8a5f'
${ noResults }
TensorFlow.NET/src/TensorFlowNET.Core/Protobuf/Struct.cs

3217 lines
122 kB
Raw Blame History 

  1. // <auto-generated>

  2. //     Generated by the protocol buffer compiler.  DO NOT EDIT!

  3. //     source: tensorflow/core/protobuf/struct.proto

  4. // </auto-generated>

  5. #pragma warning disable 1591, 0612, 3021, 8981

  6. #region Designer generated code

  7. 

  8. using pb = global::Google.Protobuf;

  9. using pbc = global::Google.Protobuf.Collections;

  10. using pbr = global::Google.Protobuf.Reflection;

  11. using scg = global::System.Collections.Generic;

  12. namespace Tensorflow {

  13. 

  14.   /// <summary>Holder for reflection information generated from tensorflow/core/protobuf/struct.proto</summary>

  15.   public static partial class StructReflection {

  16. 

  17.     #region Descriptor

  18.     /// <summary>File descriptor for tensorflow/core/protobuf/struct.proto</summary>

  19.     public static pbr::FileDescriptor Descriptor {

  20.       get { return descriptor; }

  21.     }

  22.     private static pbr::FileDescriptor descriptor;

  23. 

  24.     static StructReflection() {

  25.       byte[] descriptorData = global::System.Convert.FromBase64String(

  26.           string.Concat(

  27.             "CiV0ZW5zb3JmbG93L2NvcmUvcHJvdG9idWYvc3RydWN0LnByb3RvEgp0ZW5z",

  28.             "b3JmbG93GiZ0ZW5zb3JmbG93L2NvcmUvZnJhbWV3b3JrL3RlbnNvci5wcm90",

  29.             "bxosdGVuc29yZmxvdy9jb3JlL2ZyYW1ld29yay90ZW5zb3Jfc2hhcGUucHJv",

  30.             "dG8aJXRlbnNvcmZsb3cvY29yZS9mcmFtZXdvcmsvdHlwZXMucHJvdG8ikAUK",

  31.             "D1N0cnVjdHVyZWRWYWx1ZRIrCgpub25lX3ZhbHVlGAEgASgLMhUudGVuc29y",

  32.             "Zmxvdy5Ob25lVmFsdWVIABIXCg1mbG9hdDY0X3ZhbHVlGAsgASgBSAASFQoL",

  33.             "aW50NjRfdmFsdWUYDCABKBJIABIWCgxzdHJpbmdfdmFsdWUYDSABKAlIABIU",

  34.             "Cgpib29sX3ZhbHVlGA4gASgISAASOgoSdGVuc29yX3NoYXBlX3ZhbHVlGB8g",

  35.             "ASgLMhwudGVuc29yZmxvdy5UZW5zb3JTaGFwZVByb3RvSAASMgoSdGVuc29y",

  36.             "X2R0eXBlX3ZhbHVlGCAgASgOMhQudGVuc29yZmxvdy5EYXRhVHlwZUgAEjgK",

  37.             "EXRlbnNvcl9zcGVjX3ZhbHVlGCEgASgLMhsudGVuc29yZmxvdy5UZW5zb3JT",

  38.             "cGVjUHJvdG9IABI0Cg90eXBlX3NwZWNfdmFsdWUYIiABKAsyGS50ZW5zb3Jm",

  39.             "bG93LlR5cGVTcGVjUHJvdG9IABJHChlib3VuZGVkX3RlbnNvcl9zcGVjX3Zh",

  40.             "bHVlGCMgASgLMiIudGVuc29yZmxvdy5Cb3VuZGVkVGVuc29yU3BlY1Byb3Rv",

  41.             "SAASKwoKbGlzdF92YWx1ZRgzIAEoCzIVLnRlbnNvcmZsb3cuTGlzdFZhbHVl",

  42.             "SAASLQoLdHVwbGVfdmFsdWUYNCABKAsyFi50ZW5zb3JmbG93LlR1cGxlVmFs",

  43.             "dWVIABIrCgpkaWN0X3ZhbHVlGDUgASgLMhUudGVuc29yZmxvdy5EaWN0VmFs",

  44.             "dWVIABI4ChFuYW1lZF90dXBsZV92YWx1ZRg2IAEoCzIbLnRlbnNvcmZsb3cu",

  45.             "TmFtZWRUdXBsZVZhbHVlSABCBgoEa2luZCILCglOb25lVmFsdWUiOAoJTGlz",

  46.             "dFZhbHVlEisKBnZhbHVlcxgBIAMoCzIbLnRlbnNvcmZsb3cuU3RydWN0dXJl",

  47.             "ZFZhbHVlIjkKClR1cGxlVmFsdWUSKwoGdmFsdWVzGAEgAygLMhsudGVuc29y",

  48.             "Zmxvdy5TdHJ1Y3R1cmVkVmFsdWUiigEKCURpY3RWYWx1ZRIxCgZmaWVsZHMY",

  49.             "ASADKAsyIS50ZW5zb3JmbG93LkRpY3RWYWx1ZS5GaWVsZHNFbnRyeRpKCgtG",

  50.             "aWVsZHNFbnRyeRILCgNrZXkYASABKAkSKgoFdmFsdWUYAiABKAsyGy50ZW5z",

  51.             "b3JmbG93LlN0cnVjdHVyZWRWYWx1ZToCOAEiRAoJUGFpclZhbHVlEgsKA2tl",

  52.             "eRgBIAEoCRIqCgV2YWx1ZRgCIAEoCzIbLnRlbnNvcmZsb3cuU3RydWN0dXJl",

  53.             "ZFZhbHVlIkYKD05hbWVkVHVwbGVWYWx1ZRIMCgRuYW1lGAEgASgJEiUKBnZh",

  54.             "bHVlcxgCIAMoCzIVLnRlbnNvcmZsb3cuUGFpclZhbHVlInEKD1RlbnNvclNw",

  55.             "ZWNQcm90bxIMCgRuYW1lGAEgASgJEisKBXNoYXBlGAIgASgLMhwudGVuc29y",

  56.             "Zmxvdy5UZW5zb3JTaGFwZVByb3RvEiMKBWR0eXBlGAMgASgOMhQudGVuc29y",

  57.             "Zmxvdy5EYXRhVHlwZSLMAQoWQm91bmRlZFRlbnNvclNwZWNQcm90bxIMCgRu",

  58.             "YW1lGAEgASgJEisKBXNoYXBlGAIgASgLMhwudGVuc29yZmxvdy5UZW5zb3JT",

  59.             "aGFwZVByb3RvEiMKBWR0eXBlGAMgASgOMhQudGVuc29yZmxvdy5EYXRhVHlw",

  60.             "ZRIoCgdtaW5pbXVtGAQgASgLMhcudGVuc29yZmxvdy5UZW5zb3JQcm90bxIo",

  61.             "CgdtYXhpbXVtGAUgASgLMhcudGVuc29yZmxvdy5UZW5zb3JQcm90byL4AwoN",

  62.             "VHlwZVNwZWNQcm90bxJACg90eXBlX3NwZWNfY2xhc3MYASABKA4yJy50ZW5z",

  63.             "b3JmbG93LlR5cGVTcGVjUHJvdG8uVHlwZVNwZWNDbGFzcxIvCgp0eXBlX3N0",

  64.             "YXRlGAIgASgLMhsudGVuc29yZmxvdy5TdHJ1Y3R1cmVkVmFsdWUSHAoUdHlw",

  65.             "ZV9zcGVjX2NsYXNzX25hbWUYAyABKAkSGwoTbnVtX2ZsYXRfY29tcG9uZW50",

  66.             "cxgEIAEoBSK4AgoNVHlwZVNwZWNDbGFzcxILCgdVTktOT1dOEAASFgoSU1BB",

  67.             "UlNFX1RFTlNPUl9TUEVDEAESFwoTSU5ERVhFRF9TTElDRVNfU1BFQxACEhYK",

  68.             "ElJBR0dFRF9URU5TT1JfU1BFQxADEhUKEVRFTlNPUl9BUlJBWV9TUEVDEAQS",

  69.             "FQoRREFUQV9EQVRBU0VUX1NQRUMQBRIWChJEQVRBX0lURVJBVE9SX1NQRUMQ",

  70.             "BhIRCg1PUFRJT05BTF9TUEVDEAcSFAoQUEVSX1JFUExJQ0FfU1BFQxAIEhEK",

  71.             "DVZBUklBQkxFX1NQRUMQCRIWChJST1dfUEFSVElUSU9OX1NQRUMQChIYChRS",

  72.             "RUdJU1RFUkVEX1RZUEVfU1BFQxAMEhcKE0VYVEVOU0lPTl9UWVBFX1NQRUMQ",

  73.             "DSIECAsQC0JXWlVnaXRodWIuY29tL3RlbnNvcmZsb3cvdGVuc29yZmxvdy90",

  74.             "ZW5zb3JmbG93L2dvL2NvcmUvcHJvdG9idWYvZm9yX2NvcmVfcHJvdG9zX2dv",

  75.             "X3Byb3RvYgZwcm90bzM="));

  76.       descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,

  77.           new pbr::FileDescriptor[] { global::Tensorflow.TensorReflection.Descriptor, global::Tensorflow.TensorShapeReflection.Descriptor, global::Tensorflow.TypesReflection.Descriptor, },

  78.           new pbr::GeneratedClrTypeInfo(null, null, new pbr::GeneratedClrTypeInfo[] {

  79.             new pbr::GeneratedClrTypeInfo(typeof(global::Tensorflow.StructuredValue), global::Tensorflow.StructuredValue.Parser, new[]{ "NoneValue", "Float64Value", "Int64Value", "StringValue", "BoolValue", "TensorShapeValue", "TensorDtypeValue", "TensorSpecValue", "TypeSpecValue", "BoundedTensorSpecValue", "ListValue", "TupleValue", "DictValue", "NamedTupleValue" }, new[]{ "Kind" }, null, null, null),

  80.             new pbr::GeneratedClrTypeInfo(typeof(global::Tensorflow.NoneValue), global::Tensorflow.NoneValue.Parser, null, null, null, null, null),

  81.             new pbr::GeneratedClrTypeInfo(typeof(global::Tensorflow.ListValue), global::Tensorflow.ListValue.Parser, new[]{ "Values" }, null, null, null, null),

  82.             new pbr::GeneratedClrTypeInfo(typeof(global::Tensorflow.TupleValue), global::Tensorflow.TupleValue.Parser, new[]{ "Values" }, null, null, null, null),

  83.             new pbr::GeneratedClrTypeInfo(typeof(global::Tensorflow.DictValue), global::Tensorflow.DictValue.Parser, new[]{ "Fields" }, null, null, null, new pbr::GeneratedClrTypeInfo[] { null, }),

  84.             new pbr::GeneratedClrTypeInfo(typeof(global::Tensorflow.PairValue), global::Tensorflow.PairValue.Parser, new[]{ "Key", "Value" }, null, null, null, null),

  85.             new pbr::GeneratedClrTypeInfo(typeof(global::Tensorflow.NamedTupleValue), global::Tensorflow.NamedTupleValue.Parser, new[]{ "Name", "Values" }, null, null, null, null),

  86.             new pbr::GeneratedClrTypeInfo(typeof(global::Tensorflow.TensorSpecProto), global::Tensorflow.TensorSpecProto.Parser, new[]{ "Name", "Shape", "Dtype" }, null, null, null, null),

  87.             new pbr::GeneratedClrTypeInfo(typeof(global::Tensorflow.BoundedTensorSpecProto), global::Tensorflow.BoundedTensorSpecProto.Parser, new[]{ "Name", "Shape", "Dtype", "Minimum", "Maximum" }, null, null, null, null),

  88.             new pbr::GeneratedClrTypeInfo(typeof(global::Tensorflow.TypeSpecProto), global::Tensorflow.TypeSpecProto.Parser, new[]{ "TypeSpecClass", "TypeState", "TypeSpecClassName", "NumFlatComponents" }, null, new[]{ typeof(global::Tensorflow.TypeSpecProto.Types.TypeSpecClass) }, null, null)

  89.           }));

  90.     }

  91.     #endregion

  92. 

  93.   }

  94.   #region Messages

  95.   /// <summary>

  96.   /// `StructuredValue` represents a dynamically typed value representing various

  97.   /// data structures that are inspired by Python data structures typically used in

  98.   /// TensorFlow functions as inputs and outputs.

  99.   ///

  100.   /// For example when saving a Layer there may be a `training` argument. If the

  101.   /// user passes a boolean True/False, that switches between two concrete

  102.   /// TensorFlow functions. In order to switch between them in the same way after

  103.   /// loading the SavedModel, we need to represent "True" and "False".

  104.   ///

  105.   /// A more advanced example might be a function which takes a list of

  106.   /// dictionaries mapping from strings to Tensors. In order to map from

  107.   /// user-specified arguments `[{"a": tf.constant(1.)}, {"q": tf.constant(3.)}]`

  108.   /// after load to the right saved TensorFlow function, we need to represent the

  109.   /// nested structure and the strings, recording that we have a trace for anything

  110.   /// matching `[{"a": tf.TensorSpec(None, tf.float32)}, {"q": tf.TensorSpec([],

  111.   /// tf.float64)}]` as an example.

  112.   ///

  113.   /// Likewise functions may return nested structures of Tensors, for example

  114.   /// returning a dictionary mapping from strings to Tensors. In order for the

  115.   /// loaded function to return the same structure we need to serialize it.

  116.   ///

  117.   /// This is an ergonomic aid for working with loaded SavedModels, not a promise

  118.   /// to serialize all possible function signatures. For example we do not expect

  119.   /// to pickle generic Python objects, and ideally we'd stay language-agnostic.

  120.   /// </summary>

  121.   public sealed partial class StructuredValue : pb::IMessage<StructuredValue>

  122.   #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  123.       , pb::IBufferMessage

  124.   #endif

  125.   {

  126.     private static readonly pb::MessageParser<StructuredValue> _parser = new pb::MessageParser<StructuredValue>(() => new StructuredValue());

  127.     private pb::UnknownFieldSet _unknownFields;

  128.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  129.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  130.     public static pb::MessageParser<StructuredValue> Parser { get { return _parser; } }

  131. 

  132.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  133.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  134.     public static pbr::MessageDescriptor Descriptor {

  135.       get { return global::Tensorflow.StructReflection.Descriptor.MessageTypes[0]; }

  136.     }

  137. 

  138.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  139.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  140.     pbr::MessageDescriptor pb::IMessage.Descriptor {

  141.       get { return Descriptor; }

  142.     }

  143. 

  144.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  145.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  146.     public StructuredValue() {

  147.       OnConstruction();

  148.     }

  149. 

  150.     partial void OnConstruction();

  151. 

  152.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  153.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  154.     public StructuredValue(StructuredValue other) : this() {

  155.       switch (other.KindCase) {

  156.         case KindOneofCase.NoneValue:

  157.           NoneValue = other.NoneValue.Clone();

  158.           break;

  159.         case KindOneofCase.Float64Value:

  160.           Float64Value = other.Float64Value;

  161.           break;

  162.         case KindOneofCase.Int64Value:

  163.           Int64Value = other.Int64Value;

  164.           break;

  165.         case KindOneofCase.StringValue:

  166.           StringValue = other.StringValue;

  167.           break;

  168.         case KindOneofCase.BoolValue:

  169.           BoolValue = other.BoolValue;

  170.           break;

  171.         case KindOneofCase.TensorShapeValue:

  172.           TensorShapeValue = other.TensorShapeValue.Clone();

  173.           break;

  174.         case KindOneofCase.TensorDtypeValue:

  175.           TensorDtypeValue = other.TensorDtypeValue;

  176.           break;

  177.         case KindOneofCase.TensorSpecValue:

  178.           TensorSpecValue = other.TensorSpecValue.Clone();

  179.           break;

  180.         case KindOneofCase.TypeSpecValue:

  181.           TypeSpecValue = other.TypeSpecValue.Clone();

  182.           break;

  183.         case KindOneofCase.BoundedTensorSpecValue:

  184.           BoundedTensorSpecValue = other.BoundedTensorSpecValue.Clone();

  185.           break;

  186.         case KindOneofCase.ListValue:

  187.           ListValue = other.ListValue.Clone();

  188.           break;

  189.         case KindOneofCase.TupleValue:

  190.           TupleValue = other.TupleValue.Clone();

  191.           break;

  192.         case KindOneofCase.DictValue:

  193.           DictValue = other.DictValue.Clone();

  194.           break;

  195.         case KindOneofCase.NamedTupleValue:

  196.           NamedTupleValue = other.NamedTupleValue.Clone();

  197.           break;

  198.       }

  199. 

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

  201.     }

  202. 

  203.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  204.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  205.     public StructuredValue Clone() {

  206.       return new StructuredValue(this);

  207.     }

  208. 

  209.     /// <summary>Field number for the "none_value" field.</summary>

  210.     public const int NoneValueFieldNumber = 1;

  211.     /// <summary>

  212.     /// Represents None.

  213.     /// </summary>

  214.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  215.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  216.     public global::Tensorflow.NoneValue NoneValue {

  217.       get { return kindCase_ == KindOneofCase.NoneValue ? (global::Tensorflow.NoneValue) kind_ : null; }

  218.       set {

  219.         kind_ = value;

  220.         kindCase_ = value == null ? KindOneofCase.None : KindOneofCase.NoneValue;

  221.       }

  222.     }

  223. 

  224.     /// <summary>Field number for the "float64_value" field.</summary>

  225.     public const int Float64ValueFieldNumber = 11;

  226.     /// <summary>

  227.     /// Represents a double-precision floating-point value (a Python `float`).

  228.     /// </summary>

  229.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  230.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  231.     public double Float64Value {

  232.       get { return kindCase_ == KindOneofCase.Float64Value ? (double) kind_ : 0D; }

  233.       set {

  234.         kind_ = value;

  235.         kindCase_ = KindOneofCase.Float64Value;

  236.       }

  237.     }

  238. 

  239.     /// <summary>Field number for the "int64_value" field.</summary>

  240.     public const int Int64ValueFieldNumber = 12;

  241.     /// <summary>

  242.     /// Represents a signed integer value, limited to 64 bits.

  243.     /// Larger values from Python's arbitrary-precision integers are unsupported.

  244.     /// </summary>

  245.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  246.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  247.     public long Int64Value {

  248.       get { return kindCase_ == KindOneofCase.Int64Value ? (long) kind_ : 0L; }

  249.       set {

  250.         kind_ = value;

  251.         kindCase_ = KindOneofCase.Int64Value;

  252.       }

  253.     }

  254. 

  255.     /// <summary>Field number for the "string_value" field.</summary>

  256.     public const int StringValueFieldNumber = 13;

  257.     /// <summary>

  258.     /// Represents a string of Unicode characters stored in a Python `str`.

  259.     /// In Python 3, this is exactly what type `str` is.

  260.     /// In Python 2, this is the UTF-8 encoding of the characters.

  261.     /// For strings with ASCII characters only (as often used in TensorFlow code)

  262.     /// there is effectively no difference between the language versions.

  263.     /// The obsolescent `unicode` type of Python 2 is not supported here.

  264.     /// </summary>

  265.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  266.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  267.     public string StringValue {

  268.       get { return kindCase_ == KindOneofCase.StringValue ? (string) kind_ : ""; }

  269.       set {

  270.         kind_ = pb::ProtoPreconditions.CheckNotNull(value, "value");

  271.         kindCase_ = KindOneofCase.StringValue;

  272.       }

  273.     }

  274. 

  275.     /// <summary>Field number for the "bool_value" field.</summary>

  276.     public const int BoolValueFieldNumber = 14;

  277.     /// <summary>

  278.     /// Represents a boolean value.

  279.     /// </summary>

  280.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  281.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  282.     public bool BoolValue {

  283.       get { return kindCase_ == KindOneofCase.BoolValue ? (bool) kind_ : false; }

  284.       set {

  285.         kind_ = value;

  286.         kindCase_ = KindOneofCase.BoolValue;

  287.       }

  288.     }

  289. 

  290.     /// <summary>Field number for the "tensor_shape_value" field.</summary>

  291.     public const int TensorShapeValueFieldNumber = 31;

  292.     /// <summary>

  293.     /// Represents a TensorShape.

  294.     /// </summary>

  295.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  296.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  297.     public global::Tensorflow.TensorShapeProto TensorShapeValue {

  298.       get { return kindCase_ == KindOneofCase.TensorShapeValue ? (global::Tensorflow.TensorShapeProto) kind_ : null; }

  299.       set {

  300.         kind_ = value;

  301.         kindCase_ = value == null ? KindOneofCase.None : KindOneofCase.TensorShapeValue;

  302.       }

  303.     }

  304. 

  305.     /// <summary>Field number for the "tensor_dtype_value" field.</summary>

  306.     public const int TensorDtypeValueFieldNumber = 32;

  307.     /// <summary>

  308.     /// Represents an enum value for dtype.

  309.     /// </summary>

  310.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  311.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  312.     public global::Tensorflow.DataType TensorDtypeValue {

  313.       get { return kindCase_ == KindOneofCase.TensorDtypeValue ? (global::Tensorflow.DataType) kind_ : global::Tensorflow.DataType.DtInvalid; }

  314.       set {

  315.         kind_ = value;

  316.         kindCase_ = KindOneofCase.TensorDtypeValue;

  317.       }

  318.     }

  319. 

  320.     /// <summary>Field number for the "tensor_spec_value" field.</summary>

  321.     public const int TensorSpecValueFieldNumber = 33;

  322.     /// <summary>

  323.     /// Represents a value for tf.TensorSpec.

  324.     /// </summary>

  325.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  326.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  327.     public global::Tensorflow.TensorSpecProto TensorSpecValue {

  328.       get { return kindCase_ == KindOneofCase.TensorSpecValue ? (global::Tensorflow.TensorSpecProto) kind_ : null; }

  329.       set {

  330.         kind_ = value;

  331.         kindCase_ = value == null ? KindOneofCase.None : KindOneofCase.TensorSpecValue;

  332.       }

  333.     }

  334. 

  335.     /// <summary>Field number for the "type_spec_value" field.</summary>

  336.     public const int TypeSpecValueFieldNumber = 34;

  337.     /// <summary>

  338.     /// Represents a value for tf.TypeSpec.

  339.     /// </summary>

  340.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  341.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  342.     public global::Tensorflow.TypeSpecProto TypeSpecValue {

  343.       get { return kindCase_ == KindOneofCase.TypeSpecValue ? (global::Tensorflow.TypeSpecProto) kind_ : null; }

  344.       set {

  345.         kind_ = value;

  346.         kindCase_ = value == null ? KindOneofCase.None : KindOneofCase.TypeSpecValue;

  347.       }

  348.     }

  349. 

  350.     /// <summary>Field number for the "bounded_tensor_spec_value" field.</summary>

  351.     public const int BoundedTensorSpecValueFieldNumber = 35;

  352.     /// <summary>

  353.     /// Represents a value for tf.BoundedTensorSpec.

  354.     /// </summary>

  355.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  356.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  357.     public global::Tensorflow.BoundedTensorSpecProto BoundedTensorSpecValue {

  358.       get { return kindCase_ == KindOneofCase.BoundedTensorSpecValue ? (global::Tensorflow.BoundedTensorSpecProto) kind_ : null; }

  359.       set {

  360.         kind_ = value;

  361.         kindCase_ = value == null ? KindOneofCase.None : KindOneofCase.BoundedTensorSpecValue;

  362.       }

  363.     }

  364. 

  365.     /// <summary>Field number for the "list_value" field.</summary>

  366.     public const int ListValueFieldNumber = 51;

  367.     /// <summary>

  368.     /// Represents a list of `Value`.

  369.     /// </summary>

  370.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  371.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  372.     public global::Tensorflow.ListValue ListValue {

  373.       get { return kindCase_ == KindOneofCase.ListValue ? (global::Tensorflow.ListValue) kind_ : null; }

  374.       set {

  375.         kind_ = value;

  376.         kindCase_ = value == null ? KindOneofCase.None : KindOneofCase.ListValue;

  377.       }

  378.     }

  379. 

  380.     /// <summary>Field number for the "tuple_value" field.</summary>

  381.     public const int TupleValueFieldNumber = 52;

  382.     /// <summary>

  383.     /// Represents a tuple of `Value`.

  384.     /// </summary>

  385.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  386.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  387.     public global::Tensorflow.TupleValue TupleValue {

  388.       get { return kindCase_ == KindOneofCase.TupleValue ? (global::Tensorflow.TupleValue) kind_ : null; }

  389.       set {

  390.         kind_ = value;

  391.         kindCase_ = value == null ? KindOneofCase.None : KindOneofCase.TupleValue;

  392.       }

  393.     }

  394. 

  395.     /// <summary>Field number for the "dict_value" field.</summary>

  396.     public const int DictValueFieldNumber = 53;

  397.     /// <summary>

  398.     /// Represents a dict `Value`.

  399.     /// </summary>

  400.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  401.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  402.     public global::Tensorflow.DictValue DictValue {

  403.       get { return kindCase_ == KindOneofCase.DictValue ? (global::Tensorflow.DictValue) kind_ : null; }

  404.       set {

  405.         kind_ = value;

  406.         kindCase_ = value == null ? KindOneofCase.None : KindOneofCase.DictValue;

  407.       }

  408.     }

  409. 

  410.     /// <summary>Field number for the "named_tuple_value" field.</summary>

  411.     public const int NamedTupleValueFieldNumber = 54;

  412.     /// <summary>

  413.     /// Represents Python's namedtuple.

  414.     /// </summary>

  415.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  416.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  417.     public global::Tensorflow.NamedTupleValue NamedTupleValue {

  418.       get { return kindCase_ == KindOneofCase.NamedTupleValue ? (global::Tensorflow.NamedTupleValue) kind_ : null; }

  419.       set {

  420.         kind_ = value;

  421.         kindCase_ = value == null ? KindOneofCase.None : KindOneofCase.NamedTupleValue;

  422.       }

  423.     }

  424. 

  425.     private object kind_;

  426.     /// <summary>Enum of possible cases for the "kind" oneof.</summary>

  427.     public enum KindOneofCase {

  428.       None = 0,

  429.       NoneValue = 1,

  430.       Float64Value = 11,

  431.       Int64Value = 12,

  432.       StringValue = 13,

  433.       BoolValue = 14,

  434.       TensorShapeValue = 31,

  435.       TensorDtypeValue = 32,

  436.       TensorSpecValue = 33,

  437.       TypeSpecValue = 34,

  438.       BoundedTensorSpecValue = 35,

  439.       ListValue = 51,

  440.       TupleValue = 52,

  441.       DictValue = 53,

  442.       NamedTupleValue = 54,

  443.     }

  444.     private KindOneofCase kindCase_ = KindOneofCase.None;

  445.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  446.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  447.     public KindOneofCase KindCase {

  448.       get { return kindCase_; }

  449.     }

  450. 

  451.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  452.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  453.     public void ClearKind() {

  454.       kindCase_ = KindOneofCase.None;

  455.       kind_ = null;

  456.     }

  457. 

  458.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  459.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  460.     public override bool Equals(object other) {

  461.       return Equals(other as StructuredValue);

  462.     }

  463. 

  464.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  465.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  466.     public bool Equals(StructuredValue other) {

  467.       if (ReferenceEquals(other, null)) {

  468.         return false;

  469.       }

  470.       if (ReferenceEquals(other, this)) {

  471.         return true;

  472.       }

  473.       if (!object.Equals(NoneValue, other.NoneValue)) return false;

  474.       if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(Float64Value, other.Float64Value)) return false;

  475.       if (Int64Value != other.Int64Value) return false;

  476.       if (StringValue != other.StringValue) return false;

  477.       if (BoolValue != other.BoolValue) return false;

  478.       if (!object.Equals(TensorShapeValue, other.TensorShapeValue)) return false;

  479.       if (TensorDtypeValue != other.TensorDtypeValue) return false;

  480.       if (!object.Equals(TensorSpecValue, other.TensorSpecValue)) return false;

  481.       if (!object.Equals(TypeSpecValue, other.TypeSpecValue)) return false;

  482.       if (!object.Equals(BoundedTensorSpecValue, other.BoundedTensorSpecValue)) return false;

  483.       if (!object.Equals(ListValue, other.ListValue)) return false;

  484.       if (!object.Equals(TupleValue, other.TupleValue)) return false;

  485.       if (!object.Equals(DictValue, other.DictValue)) return false;

  486.       if (!object.Equals(NamedTupleValue, other.NamedTupleValue)) return false;

  487.       if (KindCase != other.KindCase) return false;

  488.       return Equals(_unknownFields, other._unknownFields);

  489.     }

  490. 

  491.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  492.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  493.     public override int GetHashCode() {

  494.       int hash = 1;

  495.       if (kindCase_ == KindOneofCase.NoneValue) hash ^= NoneValue.GetHashCode();

  496.       if (kindCase_ == KindOneofCase.Float64Value) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(Float64Value);

  497.       if (kindCase_ == KindOneofCase.Int64Value) hash ^= Int64Value.GetHashCode();

  498.       if (kindCase_ == KindOneofCase.StringValue) hash ^= StringValue.GetHashCode();

  499.       if (kindCase_ == KindOneofCase.BoolValue) hash ^= BoolValue.GetHashCode();

  500.       if (kindCase_ == KindOneofCase.TensorShapeValue) hash ^= TensorShapeValue.GetHashCode();

  501.       if (kindCase_ == KindOneofCase.TensorDtypeValue) hash ^= TensorDtypeValue.GetHashCode();

  502.       if (kindCase_ == KindOneofCase.TensorSpecValue) hash ^= TensorSpecValue.GetHashCode();

  503.       if (kindCase_ == KindOneofCase.TypeSpecValue) hash ^= TypeSpecValue.GetHashCode();

  504.       if (kindCase_ == KindOneofCase.BoundedTensorSpecValue) hash ^= BoundedTensorSpecValue.GetHashCode();

  505.       if (kindCase_ == KindOneofCase.ListValue) hash ^= ListValue.GetHashCode();

  506.       if (kindCase_ == KindOneofCase.TupleValue) hash ^= TupleValue.GetHashCode();

  507.       if (kindCase_ == KindOneofCase.DictValue) hash ^= DictValue.GetHashCode();

  508.       if (kindCase_ == KindOneofCase.NamedTupleValue) hash ^= NamedTupleValue.GetHashCode();

  509.       hash ^= (int) kindCase_;

  510.       if (_unknownFields != null) {

  511.         hash ^= _unknownFields.GetHashCode();

  512.       }

  513.       return hash;

  514.     }

  515. 

  516.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  517.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  518.     public override string ToString() {

  519.       return pb::JsonFormatter.ToDiagnosticString(this);

  520.     }

  521. 

  522.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  523.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  524.     public void WriteTo(pb::CodedOutputStream output) {

  525.     #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  526.       output.WriteRawMessage(this);

  527.     #else

  528.       if (kindCase_ == KindOneofCase.NoneValue) {

  529.         output.WriteRawTag(10);

  530.         output.WriteMessage(NoneValue);

  531.       }

  532.       if (kindCase_ == KindOneofCase.Float64Value) {

  533.         output.WriteRawTag(89);

  534.         output.WriteDouble(Float64Value);

  535.       }

  536.       if (kindCase_ == KindOneofCase.Int64Value) {

  537.         output.WriteRawTag(96);

  538.         output.WriteSInt64(Int64Value);

  539.       }

  540.       if (kindCase_ == KindOneofCase.StringValue) {

  541.         output.WriteRawTag(106);

  542.         output.WriteString(StringValue);

  543.       }

  544.       if (kindCase_ == KindOneofCase.BoolValue) {

  545.         output.WriteRawTag(112);

  546.         output.WriteBool(BoolValue);

  547.       }

  548.       if (kindCase_ == KindOneofCase.TensorShapeValue) {

  549.         output.WriteRawTag(250, 1);

  550.         output.WriteMessage(TensorShapeValue);

  551.       }

  552.       if (kindCase_ == KindOneofCase.TensorDtypeValue) {

  553.         output.WriteRawTag(128, 2);

  554.         output.WriteEnum((int) TensorDtypeValue);

  555.       }

  556.       if (kindCase_ == KindOneofCase.TensorSpecValue) {

  557.         output.WriteRawTag(138, 2);

  558.         output.WriteMessage(TensorSpecValue);

  559.       }

  560.       if (kindCase_ == KindOneofCase.TypeSpecValue) {

  561.         output.WriteRawTag(146, 2);

  562.         output.WriteMessage(TypeSpecValue);

  563.       }

  564.       if (kindCase_ == KindOneofCase.BoundedTensorSpecValue) {

  565.         output.WriteRawTag(154, 2);

  566.         output.WriteMessage(BoundedTensorSpecValue);

  567.       }

  568.       if (kindCase_ == KindOneofCase.ListValue) {

  569.         output.WriteRawTag(154, 3);

  570.         output.WriteMessage(ListValue);

  571.       }

  572.       if (kindCase_ == KindOneofCase.TupleValue) {

  573.         output.WriteRawTag(162, 3);

  574.         output.WriteMessage(TupleValue);

  575.       }

  576.       if (kindCase_ == KindOneofCase.DictValue) {

  577.         output.WriteRawTag(170, 3);

  578.         output.WriteMessage(DictValue);

  579.       }

  580.       if (kindCase_ == KindOneofCase.NamedTupleValue) {

  581.         output.WriteRawTag(178, 3);

  582.         output.WriteMessage(NamedTupleValue);

  583.       }

  584.       if (_unknownFields != null) {

  585.         _unknownFields.WriteTo(output);

  586.       }

  587.     #endif

  588.     }

  589. 

  590.     #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  591.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  592.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  593.     void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {

  594.       if (kindCase_ == KindOneofCase.NoneValue) {

  595.         output.WriteRawTag(10);

  596.         output.WriteMessage(NoneValue);

  597.       }

  598.       if (kindCase_ == KindOneofCase.Float64Value) {

  599.         output.WriteRawTag(89);

  600.         output.WriteDouble(Float64Value);

  601.       }

  602.       if (kindCase_ == KindOneofCase.Int64Value) {

  603.         output.WriteRawTag(96);

  604.         output.WriteSInt64(Int64Value);

  605.       }

  606.       if (kindCase_ == KindOneofCase.StringValue) {

  607.         output.WriteRawTag(106);

  608.         output.WriteString(StringValue);

  609.       }

  610.       if (kindCase_ == KindOneofCase.BoolValue) {

  611.         output.WriteRawTag(112);

  612.         output.WriteBool(BoolValue);

  613.       }

  614.       if (kindCase_ == KindOneofCase.TensorShapeValue) {

  615.         output.WriteRawTag(250, 1);

  616.         output.WriteMessage(TensorShapeValue);

  617.       }

  618.       if (kindCase_ == KindOneofCase.TensorDtypeValue) {

  619.         output.WriteRawTag(128, 2);

  620.         output.WriteEnum((int) TensorDtypeValue);

  621.       }

  622.       if (kindCase_ == KindOneofCase.TensorSpecValue) {

  623.         output.WriteRawTag(138, 2);

  624.         output.WriteMessage(TensorSpecValue);

  625.       }

  626.       if (kindCase_ == KindOneofCase.TypeSpecValue) {

  627.         output.WriteRawTag(146, 2);

  628.         output.WriteMessage(TypeSpecValue);

  629.       }

  630.       if (kindCase_ == KindOneofCase.BoundedTensorSpecValue) {

  631.         output.WriteRawTag(154, 2);

  632.         output.WriteMessage(BoundedTensorSpecValue);

  633.       }

  634.       if (kindCase_ == KindOneofCase.ListValue) {

  635.         output.WriteRawTag(154, 3);

  636.         output.WriteMessage(ListValue);

  637.       }

  638.       if (kindCase_ == KindOneofCase.TupleValue) {

  639.         output.WriteRawTag(162, 3);

  640.         output.WriteMessage(TupleValue);

  641.       }

  642.       if (kindCase_ == KindOneofCase.DictValue) {

  643.         output.WriteRawTag(170, 3);

  644.         output.WriteMessage(DictValue);

  645.       }

  646.       if (kindCase_ == KindOneofCase.NamedTupleValue) {

  647.         output.WriteRawTag(178, 3);

  648.         output.WriteMessage(NamedTupleValue);

  649.       }

  650.       if (_unknownFields != null) {

  651.         _unknownFields.WriteTo(ref output);

  652.       }

  653.     }

  654.     #endif

  655. 

  656.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  657.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  658.     public int CalculateSize() {

  659.       int size = 0;

  660.       if (kindCase_ == KindOneofCase.NoneValue) {

  661.         size += 1 + pb::CodedOutputStream.ComputeMessageSize(NoneValue);

  662.       }

  663.       if (kindCase_ == KindOneofCase.Float64Value) {

  664.         size += 1 + 8;

  665.       }

  666.       if (kindCase_ == KindOneofCase.Int64Value) {

  667.         size += 1 + pb::CodedOutputStream.ComputeSInt64Size(Int64Value);

  668.       }

  669.       if (kindCase_ == KindOneofCase.StringValue) {

  670.         size += 1 + pb::CodedOutputStream.ComputeStringSize(StringValue);

  671.       }

  672.       if (kindCase_ == KindOneofCase.BoolValue) {

  673.         size += 1 + 1;

  674.       }

  675.       if (kindCase_ == KindOneofCase.TensorShapeValue) {

  676.         size += 2 + pb::CodedOutputStream.ComputeMessageSize(TensorShapeValue);

  677.       }

  678.       if (kindCase_ == KindOneofCase.TensorDtypeValue) {

  679.         size += 2 + pb::CodedOutputStream.ComputeEnumSize((int) TensorDtypeValue);

  680.       }

  681.       if (kindCase_ == KindOneofCase.TensorSpecValue) {

  682.         size += 2 + pb::CodedOutputStream.ComputeMessageSize(TensorSpecValue);

  683.       }

  684.       if (kindCase_ == KindOneofCase.TypeSpecValue) {

  685.         size += 2 + pb::CodedOutputStream.ComputeMessageSize(TypeSpecValue);

  686.       }

  687.       if (kindCase_ == KindOneofCase.BoundedTensorSpecValue) {

  688.         size += 2 + pb::CodedOutputStream.ComputeMessageSize(BoundedTensorSpecValue);

  689.       }

  690.       if (kindCase_ == KindOneofCase.ListValue) {

  691.         size += 2 + pb::CodedOutputStream.ComputeMessageSize(ListValue);

  692.       }

  693.       if (kindCase_ == KindOneofCase.TupleValue) {

  694.         size += 2 + pb::CodedOutputStream.ComputeMessageSize(TupleValue);

  695.       }

  696.       if (kindCase_ == KindOneofCase.DictValue) {

  697.         size += 2 + pb::CodedOutputStream.ComputeMessageSize(DictValue);

  698.       }

  699.       if (kindCase_ == KindOneofCase.NamedTupleValue) {

  700.         size += 2 + pb::CodedOutputStream.ComputeMessageSize(NamedTupleValue);

  701.       }

  702.       if (_unknownFields != null) {

  703.         size += _unknownFields.CalculateSize();

  704.       }

  705.       return size;

  706.     }

  707. 

  708.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  709.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  710.     public void MergeFrom(StructuredValue other) {

  711.       if (other == null) {

  712.         return;

  713.       }

  714.       switch (other.KindCase) {

  715.         case KindOneofCase.NoneValue:

  716.           if (NoneValue == null) {

  717.             NoneValue = new global::Tensorflow.NoneValue();

  718.           }

  719.           NoneValue.MergeFrom(other.NoneValue);

  720.           break;

  721.         case KindOneofCase.Float64Value:

  722.           Float64Value = other.Float64Value;

  723.           break;

  724.         case KindOneofCase.Int64Value:

  725.           Int64Value = other.Int64Value;

  726.           break;

  727.         case KindOneofCase.StringValue:

  728.           StringValue = other.StringValue;

  729.           break;

  730.         case KindOneofCase.BoolValue:

  731.           BoolValue = other.BoolValue;

  732.           break;

  733.         case KindOneofCase.TensorShapeValue:

  734.           if (TensorShapeValue == null) {

  735.             TensorShapeValue = new global::Tensorflow.TensorShapeProto();

  736.           }

  737.           TensorShapeValue.MergeFrom(other.TensorShapeValue);

  738.           break;

  739.         case KindOneofCase.TensorDtypeValue:

  740.           TensorDtypeValue = other.TensorDtypeValue;

  741.           break;

  742.         case KindOneofCase.TensorSpecValue:

  743.           if (TensorSpecValue == null) {

  744.             TensorSpecValue = new global::Tensorflow.TensorSpecProto();

  745.           }

  746.           TensorSpecValue.MergeFrom(other.TensorSpecValue);

  747.           break;

  748.         case KindOneofCase.TypeSpecValue:

  749.           if (TypeSpecValue == null) {

  750.             TypeSpecValue = new global::Tensorflow.TypeSpecProto();

  751.           }

  752.           TypeSpecValue.MergeFrom(other.TypeSpecValue);

  753.           break;

  754.         case KindOneofCase.BoundedTensorSpecValue:

  755.           if (BoundedTensorSpecValue == null) {

  756.             BoundedTensorSpecValue = new global::Tensorflow.BoundedTensorSpecProto();

  757.           }

  758.           BoundedTensorSpecValue.MergeFrom(other.BoundedTensorSpecValue);

  759.           break;

  760.         case KindOneofCase.ListValue:

  761.           if (ListValue == null) {

  762.             ListValue = new global::Tensorflow.ListValue();

  763.           }

  764.           ListValue.MergeFrom(other.ListValue);

  765.           break;

  766.         case KindOneofCase.TupleValue:

  767.           if (TupleValue == null) {

  768.             TupleValue = new global::Tensorflow.TupleValue();

  769.           }

  770.           TupleValue.MergeFrom(other.TupleValue);

  771.           break;

  772.         case KindOneofCase.DictValue:

  773.           if (DictValue == null) {

  774.             DictValue = new global::Tensorflow.DictValue();

  775.           }

  776.           DictValue.MergeFrom(other.DictValue);

  777.           break;

  778.         case KindOneofCase.NamedTupleValue:

  779.           if (NamedTupleValue == null) {

  780.             NamedTupleValue = new global::Tensorflow.NamedTupleValue();

  781.           }

  782.           NamedTupleValue.MergeFrom(other.NamedTupleValue);

  783.           break;

  784.       }

  785. 

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

  787.     }

  788. 

  789.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  790.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  791.     public void MergeFrom(pb::CodedInputStream input) {

  792.     #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  793.       input.ReadRawMessage(this);

  794.     #else

  795.       uint tag;

  796.       while ((tag = input.ReadTag()) != 0) {

  797.         switch(tag) {

  798.           default:

  799.             _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);

  800.             break;

  801.           case 10: {

  802.             global::Tensorflow.NoneValue subBuilder = new global::Tensorflow.NoneValue();

  803.             if (kindCase_ == KindOneofCase.NoneValue) {

  804.               subBuilder.MergeFrom(NoneValue);

  805.             }

  806.             input.ReadMessage(subBuilder);

  807.             NoneValue = subBuilder;

  808.             break;

  809.           }

  810.           case 89: {

  811.             Float64Value = input.ReadDouble();

  812.             break;

  813.           }

  814.           case 96: {

  815.             Int64Value = input.ReadSInt64();

  816.             break;

  817.           }

  818.           case 106: {

  819.             StringValue = input.ReadString();

  820.             break;

  821.           }

  822.           case 112: {

  823.             BoolValue = input.ReadBool();

  824.             break;

  825.           }

  826.           case 250: {

  827.             global::Tensorflow.TensorShapeProto subBuilder = new global::Tensorflow.TensorShapeProto();

  828.             if (kindCase_ == KindOneofCase.TensorShapeValue) {

  829.               subBuilder.MergeFrom(TensorShapeValue);

  830.             }

  831.             input.ReadMessage(subBuilder);

  832.             TensorShapeValue = subBuilder;

  833.             break;

  834.           }

  835.           case 256: {

  836.             kind_ = input.ReadEnum();

  837.             kindCase_ = KindOneofCase.TensorDtypeValue;

  838.             break;

  839.           }

  840.           case 266: {

  841.             global::Tensorflow.TensorSpecProto subBuilder = new global::Tensorflow.TensorSpecProto();

  842.             if (kindCase_ == KindOneofCase.TensorSpecValue) {

  843.               subBuilder.MergeFrom(TensorSpecValue);

  844.             }

  845.             input.ReadMessage(subBuilder);

  846.             TensorSpecValue = subBuilder;

  847.             break;

  848.           }

  849.           case 274: {

  850.             global::Tensorflow.TypeSpecProto subBuilder = new global::Tensorflow.TypeSpecProto();

  851.             if (kindCase_ == KindOneofCase.TypeSpecValue) {

  852.               subBuilder.MergeFrom(TypeSpecValue);

  853.             }

  854.             input.ReadMessage(subBuilder);

  855.             TypeSpecValue = subBuilder;

  856.             break;

  857.           }

  858.           case 282: {

  859.             global::Tensorflow.BoundedTensorSpecProto subBuilder = new global::Tensorflow.BoundedTensorSpecProto();

  860.             if (kindCase_ == KindOneofCase.BoundedTensorSpecValue) {

  861.               subBuilder.MergeFrom(BoundedTensorSpecValue);

  862.             }

  863.             input.ReadMessage(subBuilder);

  864.             BoundedTensorSpecValue = subBuilder;

  865.             break;

  866.           }

  867.           case 410: {

  868.             global::Tensorflow.ListValue subBuilder = new global::Tensorflow.ListValue();

  869.             if (kindCase_ == KindOneofCase.ListValue) {

  870.               subBuilder.MergeFrom(ListValue);

  871.             }

  872.             input.ReadMessage(subBuilder);

  873.             ListValue = subBuilder;

  874.             break;

  875.           }

  876.           case 418: {

  877.             global::Tensorflow.TupleValue subBuilder = new global::Tensorflow.TupleValue();

  878.             if (kindCase_ == KindOneofCase.TupleValue) {

  879.               subBuilder.MergeFrom(TupleValue);

  880.             }

  881.             input.ReadMessage(subBuilder);

  882.             TupleValue = subBuilder;

  883.             break;

  884.           }

  885.           case 426: {

  886.             global::Tensorflow.DictValue subBuilder = new global::Tensorflow.DictValue();

  887.             if (kindCase_ == KindOneofCase.DictValue) {

  888.               subBuilder.MergeFrom(DictValue);

  889.             }

  890.             input.ReadMessage(subBuilder);

  891.             DictValue = subBuilder;

  892.             break;

  893.           }

  894.           case 434: {

  895.             global::Tensorflow.NamedTupleValue subBuilder = new global::Tensorflow.NamedTupleValue();

  896.             if (kindCase_ == KindOneofCase.NamedTupleValue) {

  897.               subBuilder.MergeFrom(NamedTupleValue);

  898.             }

  899.             input.ReadMessage(subBuilder);

  900.             NamedTupleValue = subBuilder;

  901.             break;

  902.           }

  903.         }

  904.       }

  905.     #endif

  906.     }

  907. 

  908.     #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  909.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  910.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  911.     void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {

  912.       uint tag;

  913.       while ((tag = input.ReadTag()) != 0) {

  914.         switch(tag) {

  915.           default:

  916.             _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);

  917.             break;

  918.           case 10: {

  919.             global::Tensorflow.NoneValue subBuilder = new global::Tensorflow.NoneValue();

  920.             if (kindCase_ == KindOneofCase.NoneValue) {

  921.               subBuilder.MergeFrom(NoneValue);

  922.             }

  923.             input.ReadMessage(subBuilder);

  924.             NoneValue = subBuilder;

  925.             break;

  926.           }

  927.           case 89: {

  928.             Float64Value = input.ReadDouble();

  929.             break;

  930.           }

  931.           case 96: {

  932.             Int64Value = input.ReadSInt64();

  933.             break;

  934.           }

  935.           case 106: {

  936.             StringValue = input.ReadString();

  937.             break;

  938.           }

  939.           case 112: {

  940.             BoolValue = input.ReadBool();

  941.             break;

  942.           }

  943.           case 250: {

  944.             global::Tensorflow.TensorShapeProto subBuilder = new global::Tensorflow.TensorShapeProto();

  945.             if (kindCase_ == KindOneofCase.TensorShapeValue) {

  946.               subBuilder.MergeFrom(TensorShapeValue);

  947.             }

  948.             input.ReadMessage(subBuilder);

  949.             TensorShapeValue = subBuilder;

  950.             break;

  951.           }

  952.           case 256: {

  953.             kind_ = input.ReadEnum();

  954.             kindCase_ = KindOneofCase.TensorDtypeValue;

  955.             break;

  956.           }

  957.           case 266: {

  958.             global::Tensorflow.TensorSpecProto subBuilder = new global::Tensorflow.TensorSpecProto();

  959.             if (kindCase_ == KindOneofCase.TensorSpecValue) {

  960.               subBuilder.MergeFrom(TensorSpecValue);

  961.             }

  962.             input.ReadMessage(subBuilder);

  963.             TensorSpecValue = subBuilder;

  964.             break;

  965.           }

  966.           case 274: {

  967.             global::Tensorflow.TypeSpecProto subBuilder = new global::Tensorflow.TypeSpecProto();

  968.             if (kindCase_ == KindOneofCase.TypeSpecValue) {

  969.               subBuilder.MergeFrom(TypeSpecValue);

  970.             }

  971.             input.ReadMessage(subBuilder);

  972.             TypeSpecValue = subBuilder;

  973.             break;

  974.           }

  975.           case 282: {

  976.             global::Tensorflow.BoundedTensorSpecProto subBuilder = new global::Tensorflow.BoundedTensorSpecProto();

  977.             if (kindCase_ == KindOneofCase.BoundedTensorSpecValue) {

  978.               subBuilder.MergeFrom(BoundedTensorSpecValue);

  979.             }

  980.             input.ReadMessage(subBuilder);

  981.             BoundedTensorSpecValue = subBuilder;

  982.             break;

  983.           }

  984.           case 410: {

  985.             global::Tensorflow.ListValue subBuilder = new global::Tensorflow.ListValue();

  986.             if (kindCase_ == KindOneofCase.ListValue) {

  987.               subBuilder.MergeFrom(ListValue);

  988.             }

  989.             input.ReadMessage(subBuilder);

  990.             ListValue = subBuilder;

  991.             break;

  992.           }

  993.           case 418: {

  994.             global::Tensorflow.TupleValue subBuilder = new global::Tensorflow.TupleValue();

  995.             if (kindCase_ == KindOneofCase.TupleValue) {

  996.               subBuilder.MergeFrom(TupleValue);

  997.             }

  998.             input.ReadMessage(subBuilder);

  999.             TupleValue = subBuilder;

  1000.             break;

  1001.           }

  1002.           case 426: {

  1003.             global::Tensorflow.DictValue subBuilder = new global::Tensorflow.DictValue();

  1004.             if (kindCase_ == KindOneofCase.DictValue) {

  1005.               subBuilder.MergeFrom(DictValue);

  1006.             }

  1007.             input.ReadMessage(subBuilder);

  1008.             DictValue = subBuilder;

  1009.             break;

  1010.           }

  1011.           case 434: {

  1012.             global::Tensorflow.NamedTupleValue subBuilder = new global::Tensorflow.NamedTupleValue();

  1013.             if (kindCase_ == KindOneofCase.NamedTupleValue) {

  1014.               subBuilder.MergeFrom(NamedTupleValue);

  1015.             }

  1016.             input.ReadMessage(subBuilder);

  1017.             NamedTupleValue = subBuilder;

  1018.             break;

  1019.           }

  1020.         }

  1021.       }

  1022.     }

  1023.     #endif

  1024. 

  1025.   }

  1026. 

  1027.   /// <summary>

  1028.   /// Represents None.

  1029.   /// </summary>

  1030.   public sealed partial class NoneValue : pb::IMessage<NoneValue>

  1031.   #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  1032.       , pb::IBufferMessage

  1033.   #endif

  1034.   {

  1035.     private static readonly pb::MessageParser<NoneValue> _parser = new pb::MessageParser<NoneValue>(() => new NoneValue());

  1036.     private pb::UnknownFieldSet _unknownFields;

  1037.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1038.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1039.     public static pb::MessageParser<NoneValue> Parser { get { return _parser; } }

  1040. 

  1041.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1042.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1043.     public static pbr::MessageDescriptor Descriptor {

  1044.       get { return global::Tensorflow.StructReflection.Descriptor.MessageTypes[1]; }

  1045.     }

  1046. 

  1047.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1048.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1049.     pbr::MessageDescriptor pb::IMessage.Descriptor {

  1050.       get { return Descriptor; }

  1051.     }

  1052. 

  1053.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1054.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1055.     public NoneValue() {

  1056.       OnConstruction();

  1057.     }

  1058. 

  1059.     partial void OnConstruction();

  1060. 

  1061.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1062.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1063.     public NoneValue(NoneValue other) : this() {

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

  1065.     }

  1066. 

  1067.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1068.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1069.     public NoneValue Clone() {

  1070.       return new NoneValue(this);

  1071.     }

  1072. 

  1073.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1074.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1075.     public override bool Equals(object other) {

  1076.       return Equals(other as NoneValue);

  1077.     }

  1078. 

  1079.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1080.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1081.     public bool Equals(NoneValue other) {

  1082.       if (ReferenceEquals(other, null)) {

  1083.         return false;

  1084.       }

  1085.       if (ReferenceEquals(other, this)) {

  1086.         return true;

  1087.       }

  1088.       return Equals(_unknownFields, other._unknownFields);

  1089.     }

  1090. 

  1091.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1092.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1093.     public override int GetHashCode() {

  1094.       int hash = 1;

  1095.       if (_unknownFields != null) {

  1096.         hash ^= _unknownFields.GetHashCode();

  1097.       }

  1098.       return hash;

  1099.     }

  1100. 

  1101.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1102.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1103.     public override string ToString() {

  1104.       return pb::JsonFormatter.ToDiagnosticString(this);

  1105.     }

  1106. 

  1107.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1108.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1109.     public void WriteTo(pb::CodedOutputStream output) {

  1110.     #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  1111.       output.WriteRawMessage(this);

  1112.     #else

  1113.       if (_unknownFields != null) {

  1114.         _unknownFields.WriteTo(output);

  1115.       }

  1116.     #endif

  1117.     }

  1118. 

  1119.     #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  1120.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1121.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1122.     void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {

  1123.       if (_unknownFields != null) {

  1124.         _unknownFields.WriteTo(ref output);

  1125.       }

  1126.     }

  1127.     #endif

  1128. 

  1129.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1130.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1131.     public int CalculateSize() {

  1132.       int size = 0;

  1133.       if (_unknownFields != null) {

  1134.         size += _unknownFields.CalculateSize();

  1135.       }

  1136.       return size;

  1137.     }

  1138. 

  1139.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1140.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1141.     public void MergeFrom(NoneValue other) {

  1142.       if (other == null) {

  1143.         return;

  1144.       }

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

  1146.     }

  1147. 

  1148.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1149.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1150.     public void MergeFrom(pb::CodedInputStream input) {

  1151.     #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  1152.       input.ReadRawMessage(this);

  1153.     #else

  1154.       uint tag;

  1155.       while ((tag = input.ReadTag()) != 0) {

  1156.         switch(tag) {

  1157.           default:

  1158.             _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);

  1159.             break;

  1160.         }

  1161.       }

  1162.     #endif

  1163.     }

  1164. 

  1165.     #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  1166.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1167.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1168.     void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {

  1169.       uint tag;

  1170.       while ((tag = input.ReadTag()) != 0) {

  1171.         switch(tag) {

  1172.           default:

  1173.             _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);

  1174.             break;

  1175.         }

  1176.       }

  1177.     }

  1178.     #endif

  1179. 

  1180.   }

  1181. 

  1182.   /// <summary>

  1183.   /// Represents a Python list.

  1184.   /// </summary>

  1185.   public sealed partial class ListValue : pb::IMessage<ListValue>

  1186.   #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  1187.       , pb::IBufferMessage

  1188.   #endif

  1189.   {

  1190.     private static readonly pb::MessageParser<ListValue> _parser = new pb::MessageParser<ListValue>(() => new ListValue());

  1191.     private pb::UnknownFieldSet _unknownFields;

  1192.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1193.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1194.     public static pb::MessageParser<ListValue> Parser { get { return _parser; } }

  1195. 

  1196.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1197.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1198.     public static pbr::MessageDescriptor Descriptor {

  1199.       get { return global::Tensorflow.StructReflection.Descriptor.MessageTypes[2]; }

  1200.     }

  1201. 

  1202.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1203.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1204.     pbr::MessageDescriptor pb::IMessage.Descriptor {

  1205.       get { return Descriptor; }

  1206.     }

  1207. 

  1208.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1209.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1210.     public ListValue() {

  1211.       OnConstruction();

  1212.     }

  1213. 

  1214.     partial void OnConstruction();

  1215. 

  1216.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1217.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1218.     public ListValue(ListValue other) : this() {

  1219.       values_ = other.values_.Clone();

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

  1221.     }

  1222. 

  1223.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1224.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1225.     public ListValue Clone() {

  1226.       return new ListValue(this);

  1227.     }

  1228. 

  1229.     /// <summary>Field number for the "values" field.</summary>

  1230.     public const int ValuesFieldNumber = 1;

  1231.     private static readonly pb::FieldCodec<global::Tensorflow.StructuredValue> _repeated_values_codec

  1232.         = pb::FieldCodec.ForMessage(10, global::Tensorflow.StructuredValue.Parser);

  1233.     private readonly pbc::RepeatedField<global::Tensorflow.StructuredValue> values_ = new pbc::RepeatedField<global::Tensorflow.StructuredValue>();

  1234.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1235.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1236.     public pbc::RepeatedField<global::Tensorflow.StructuredValue> Values {

  1237.       get { return values_; }

  1238.     }

  1239. 

  1240.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1241.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1242.     public override bool Equals(object other) {

  1243.       return Equals(other as ListValue);

  1244.     }

  1245. 

  1246.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1247.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1248.     public bool Equals(ListValue other) {

  1249.       if (ReferenceEquals(other, null)) {

  1250.         return false;

  1251.       }

  1252.       if (ReferenceEquals(other, this)) {

  1253.         return true;

  1254.       }

  1255.       if(!values_.Equals(other.values_)) return false;

  1256.       return Equals(_unknownFields, other._unknownFields);

  1257.     }

  1258. 

  1259.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1260.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1261.     public override int GetHashCode() {

  1262.       int hash = 1;

  1263.       hash ^= values_.GetHashCode();

  1264.       if (_unknownFields != null) {

  1265.         hash ^= _unknownFields.GetHashCode();

  1266.       }

  1267.       return hash;

  1268.     }

  1269. 

  1270.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1271.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1272.     public override string ToString() {

  1273.       return pb::JsonFormatter.ToDiagnosticString(this);

  1274.     }

  1275. 

  1276.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1277.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1278.     public void WriteTo(pb::CodedOutputStream output) {

  1279.     #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  1280.       output.WriteRawMessage(this);

  1281.     #else

  1282.       values_.WriteTo(output, _repeated_values_codec);

  1283.       if (_unknownFields != null) {

  1284.         _unknownFields.WriteTo(output);

  1285.       }

  1286.     #endif

  1287.     }

  1288. 

  1289.     #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  1290.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1291.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1292.     void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {

  1293.       values_.WriteTo(ref output, _repeated_values_codec);

  1294.       if (_unknownFields != null) {

  1295.         _unknownFields.WriteTo(ref output);

  1296.       }

  1297.     }

  1298.     #endif

  1299. 

  1300.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1301.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1302.     public int CalculateSize() {

  1303.       int size = 0;

  1304.       size += values_.CalculateSize(_repeated_values_codec);

  1305.       if (_unknownFields != null) {

  1306.         size += _unknownFields.CalculateSize();

  1307.       }

  1308.       return size;

  1309.     }

  1310. 

  1311.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1312.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1313.     public void MergeFrom(ListValue other) {

  1314.       if (other == null) {

  1315.         return;

  1316.       }

  1317.       values_.Add(other.values_);

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

  1319.     }

  1320. 

  1321.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1322.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1323.     public void MergeFrom(pb::CodedInputStream input) {

  1324.     #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  1325.       input.ReadRawMessage(this);

  1326.     #else

  1327.       uint tag;

  1328.       while ((tag = input.ReadTag()) != 0) {

  1329.         switch(tag) {

  1330.           default:

  1331.             _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);

  1332.             break;

  1333.           case 10: {

  1334.             values_.AddEntriesFrom(input, _repeated_values_codec);

  1335.             break;

  1336.           }

  1337.         }

  1338.       }

  1339.     #endif

  1340.     }

  1341. 

  1342.     #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  1343.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1344.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1345.     void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {

  1346.       uint tag;

  1347.       while ((tag = input.ReadTag()) != 0) {

  1348.         switch(tag) {

  1349.           default:

  1350.             _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);

  1351.             break;

  1352.           case 10: {

  1353.             values_.AddEntriesFrom(ref input, _repeated_values_codec);

  1354.             break;

  1355.           }

  1356.         }

  1357.       }

  1358.     }

  1359.     #endif

  1360. 

  1361.   }

  1362. 

  1363.   /// <summary>

  1364.   /// Represents a Python tuple.

  1365.   /// </summary>

  1366.   public sealed partial class TupleValue : pb::IMessage<TupleValue>

  1367.   #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  1368.       , pb::IBufferMessage

  1369.   #endif

  1370.   {

  1371.     private static readonly pb::MessageParser<TupleValue> _parser = new pb::MessageParser<TupleValue>(() => new TupleValue());

  1372.     private pb::UnknownFieldSet _unknownFields;

  1373.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1374.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1375.     public static pb::MessageParser<TupleValue> Parser { get { return _parser; } }

  1376. 

  1377.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1378.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1379.     public static pbr::MessageDescriptor Descriptor {

  1380.       get { return global::Tensorflow.StructReflection.Descriptor.MessageTypes[3]; }

  1381.     }

  1382. 

  1383.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1384.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1385.     pbr::MessageDescriptor pb::IMessage.Descriptor {

  1386.       get { return Descriptor; }

  1387.     }

  1388. 

  1389.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1390.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1391.     public TupleValue() {

  1392.       OnConstruction();

  1393.     }

  1394. 

  1395.     partial void OnConstruction();

  1396. 

  1397.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1398.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1399.     public TupleValue(TupleValue other) : this() {

  1400.       values_ = other.values_.Clone();

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

  1402.     }

  1403. 

  1404.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1405.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1406.     public TupleValue Clone() {

  1407.       return new TupleValue(this);

  1408.     }

  1409. 

  1410.     /// <summary>Field number for the "values" field.</summary>

  1411.     public const int ValuesFieldNumber = 1;

  1412.     private static readonly pb::FieldCodec<global::Tensorflow.StructuredValue> _repeated_values_codec

  1413.         = pb::FieldCodec.ForMessage(10, global::Tensorflow.StructuredValue.Parser);

  1414.     private readonly pbc::RepeatedField<global::Tensorflow.StructuredValue> values_ = new pbc::RepeatedField<global::Tensorflow.StructuredValue>();

  1415.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1416.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1417.     public pbc::RepeatedField<global::Tensorflow.StructuredValue> Values {

  1418.       get { return values_; }

  1419.     }

  1420. 

  1421.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1422.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1423.     public override bool Equals(object other) {

  1424.       return Equals(other as TupleValue);

  1425.     }

  1426. 

  1427.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1428.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1429.     public bool Equals(TupleValue other) {

  1430.       if (ReferenceEquals(other, null)) {

  1431.         return false;

  1432.       }

  1433.       if (ReferenceEquals(other, this)) {

  1434.         return true;

  1435.       }

  1436.       if(!values_.Equals(other.values_)) return false;

  1437.       return Equals(_unknownFields, other._unknownFields);

  1438.     }

  1439. 

  1440.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1441.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1442.     public override int GetHashCode() {

  1443.       int hash = 1;

  1444.       hash ^= values_.GetHashCode();

  1445.       if (_unknownFields != null) {

  1446.         hash ^= _unknownFields.GetHashCode();

  1447.       }

  1448.       return hash;

  1449.     }

  1450. 

  1451.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1452.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1453.     public override string ToString() {

  1454.       return pb::JsonFormatter.ToDiagnosticString(this);

  1455.     }

  1456. 

  1457.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1458.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1459.     public void WriteTo(pb::CodedOutputStream output) {

  1460.     #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  1461.       output.WriteRawMessage(this);

  1462.     #else

  1463.       values_.WriteTo(output, _repeated_values_codec);

  1464.       if (_unknownFields != null) {

  1465.         _unknownFields.WriteTo(output);

  1466.       }

  1467.     #endif

  1468.     }

  1469. 

  1470.     #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  1471.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1472.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1473.     void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {

  1474.       values_.WriteTo(ref output, _repeated_values_codec);

  1475.       if (_unknownFields != null) {

  1476.         _unknownFields.WriteTo(ref output);

  1477.       }

  1478.     }

  1479.     #endif

  1480. 

  1481.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1482.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1483.     public int CalculateSize() {

  1484.       int size = 0;

  1485.       size += values_.CalculateSize(_repeated_values_codec);

  1486.       if (_unknownFields != null) {

  1487.         size += _unknownFields.CalculateSize();

  1488.       }

  1489.       return size;

  1490.     }

  1491. 

  1492.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1493.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1494.     public void MergeFrom(TupleValue other) {

  1495.       if (other == null) {

  1496.         return;

  1497.       }

  1498.       values_.Add(other.values_);

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

  1500.     }

  1501. 

  1502.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1503.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1504.     public void MergeFrom(pb::CodedInputStream input) {

  1505.     #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  1506.       input.ReadRawMessage(this);

  1507.     #else

  1508.       uint tag;

  1509.       while ((tag = input.ReadTag()) != 0) {

  1510.         switch(tag) {

  1511.           default:

  1512.             _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);

  1513.             break;

  1514.           case 10: {

  1515.             values_.AddEntriesFrom(input, _repeated_values_codec);

  1516.             break;

  1517.           }

  1518.         }

  1519.       }

  1520.     #endif

  1521.     }

  1522. 

  1523.     #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  1524.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1525.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1526.     void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {

  1527.       uint tag;

  1528.       while ((tag = input.ReadTag()) != 0) {

  1529.         switch(tag) {

  1530.           default:

  1531.             _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);

  1532.             break;

  1533.           case 10: {

  1534.             values_.AddEntriesFrom(ref input, _repeated_values_codec);

  1535.             break;

  1536.           }

  1537.         }

  1538.       }

  1539.     }

  1540.     #endif

  1541. 

  1542.   }

  1543. 

  1544.   /// <summary>

  1545.   /// Represents a Python dict keyed by `str`.

  1546.   /// The comment on Unicode from Value.string_value applies analogously.

  1547.   /// </summary>

  1548.   public sealed partial class DictValue : pb::IMessage<DictValue>

  1549.   #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  1550.       , pb::IBufferMessage

  1551.   #endif

  1552.   {

  1553.     private static readonly pb::MessageParser<DictValue> _parser = new pb::MessageParser<DictValue>(() => new DictValue());

  1554.     private pb::UnknownFieldSet _unknownFields;

  1555.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1556.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1557.     public static pb::MessageParser<DictValue> Parser { get { return _parser; } }

  1558. 

  1559.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1560.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1561.     public static pbr::MessageDescriptor Descriptor {

  1562.       get { return global::Tensorflow.StructReflection.Descriptor.MessageTypes[4]; }

  1563.     }

  1564. 

  1565.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1566.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1567.     pbr::MessageDescriptor pb::IMessage.Descriptor {

  1568.       get { return Descriptor; }

  1569.     }

  1570. 

  1571.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1572.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1573.     public DictValue() {

  1574.       OnConstruction();

  1575.     }

  1576. 

  1577.     partial void OnConstruction();

  1578. 

  1579.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1580.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1581.     public DictValue(DictValue other) : this() {

  1582.       fields_ = other.fields_.Clone();

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

  1584.     }

  1585. 

  1586.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1587.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1588.     public DictValue Clone() {

  1589.       return new DictValue(this);

  1590.     }

  1591. 

  1592.     /// <summary>Field number for the "fields" field.</summary>

  1593.     public const int FieldsFieldNumber = 1;

  1594.     private static readonly pbc::MapField<string, global::Tensorflow.StructuredValue>.Codec _map_fields_codec

  1595.         = new pbc::MapField<string, global::Tensorflow.StructuredValue>.Codec(pb::FieldCodec.ForString(10, ""), pb::FieldCodec.ForMessage(18, global::Tensorflow.StructuredValue.Parser), 10);

  1596.     private readonly pbc::MapField<string, global::Tensorflow.StructuredValue> fields_ = new pbc::MapField<string, global::Tensorflow.StructuredValue>();

  1597.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1598.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1599.     public pbc::MapField<string, global::Tensorflow.StructuredValue> Fields {

  1600.       get { return fields_; }

  1601.     }

  1602. 

  1603.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1604.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1605.     public override bool Equals(object other) {

  1606.       return Equals(other as DictValue);

  1607.     }

  1608. 

  1609.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1610.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1611.     public bool Equals(DictValue other) {

  1612.       if (ReferenceEquals(other, null)) {

  1613.         return false;

  1614.       }

  1615.       if (ReferenceEquals(other, this)) {

  1616.         return true;

  1617.       }

  1618.       if (!Fields.Equals(other.Fields)) return false;

  1619.       return Equals(_unknownFields, other._unknownFields);

  1620.     }

  1621. 

  1622.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1623.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1624.     public override int GetHashCode() {

  1625.       int hash = 1;

  1626.       hash ^= Fields.GetHashCode();

  1627.       if (_unknownFields != null) {

  1628.         hash ^= _unknownFields.GetHashCode();

  1629.       }

  1630.       return hash;

  1631.     }

  1632. 

  1633.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1634.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1635.     public override string ToString() {

  1636.       return pb::JsonFormatter.ToDiagnosticString(this);

  1637.     }

  1638. 

  1639.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1640.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1641.     public void WriteTo(pb::CodedOutputStream output) {

  1642.     #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  1643.       output.WriteRawMessage(this);

  1644.     #else

  1645.       fields_.WriteTo(output, _map_fields_codec);

  1646.       if (_unknownFields != null) {

  1647.         _unknownFields.WriteTo(output);

  1648.       }

  1649.     #endif

  1650.     }

  1651. 

  1652.     #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  1653.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1654.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1655.     void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {

  1656.       fields_.WriteTo(ref output, _map_fields_codec);

  1657.       if (_unknownFields != null) {

  1658.         _unknownFields.WriteTo(ref output);

  1659.       }

  1660.     }

  1661.     #endif

  1662. 

  1663.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1664.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1665.     public int CalculateSize() {

  1666.       int size = 0;

  1667.       size += fields_.CalculateSize(_map_fields_codec);

  1668.       if (_unknownFields != null) {

  1669.         size += _unknownFields.CalculateSize();

  1670.       }

  1671.       return size;

  1672.     }

  1673. 

  1674.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1675.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1676.     public void MergeFrom(DictValue other) {

  1677.       if (other == null) {

  1678.         return;

  1679.       }

  1680.       fields_.MergeFrom(other.fields_);

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

  1682.     }

  1683. 

  1684.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1685.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1686.     public void MergeFrom(pb::CodedInputStream input) {

  1687.     #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  1688.       input.ReadRawMessage(this);

  1689.     #else

  1690.       uint tag;

  1691.       while ((tag = input.ReadTag()) != 0) {

  1692.         switch(tag) {

  1693.           default:

  1694.             _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);

  1695.             break;

  1696.           case 10: {

  1697.             fields_.AddEntriesFrom(input, _map_fields_codec);

  1698.             break;

  1699.           }

  1700.         }

  1701.       }

  1702.     #endif

  1703.     }

  1704. 

  1705.     #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  1706.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1707.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1708.     void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {

  1709.       uint tag;

  1710.       while ((tag = input.ReadTag()) != 0) {

  1711.         switch(tag) {

  1712.           default:

  1713.             _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);

  1714.             break;

  1715.           case 10: {

  1716.             fields_.AddEntriesFrom(ref input, _map_fields_codec);

  1717.             break;

  1718.           }

  1719.         }

  1720.       }

  1721.     }

  1722.     #endif

  1723. 

  1724.   }

  1725. 

  1726.   /// <summary>

  1727.   /// Represents a (key, value) pair.

  1728.   /// </summary>

  1729.   public sealed partial class PairValue : pb::IMessage<PairValue>

  1730.   #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  1731.       , pb::IBufferMessage

  1732.   #endif

  1733.   {

  1734.     private static readonly pb::MessageParser<PairValue> _parser = new pb::MessageParser<PairValue>(() => new PairValue());

  1735.     private pb::UnknownFieldSet _unknownFields;

  1736.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1737.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1738.     public static pb::MessageParser<PairValue> Parser { get { return _parser; } }

  1739. 

  1740.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1741.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1742.     public static pbr::MessageDescriptor Descriptor {

  1743.       get { return global::Tensorflow.StructReflection.Descriptor.MessageTypes[5]; }

  1744.     }

  1745. 

  1746.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1747.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1748.     pbr::MessageDescriptor pb::IMessage.Descriptor {

  1749.       get { return Descriptor; }

  1750.     }

  1751. 

  1752.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1753.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1754.     public PairValue() {

  1755.       OnConstruction();

  1756.     }

  1757. 

  1758.     partial void OnConstruction();

  1759. 

  1760.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1761.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1762.     public PairValue(PairValue other) : this() {

  1763.       key_ = other.key_;

  1764.       value_ = other.value_ != null ? other.value_.Clone() : null;

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

  1766.     }

  1767. 

  1768.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1769.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1770.     public PairValue Clone() {

  1771.       return new PairValue(this);

  1772.     }

  1773. 

  1774.     /// <summary>Field number for the "key" field.</summary>

  1775.     public const int KeyFieldNumber = 1;

  1776.     private string key_ = "";

  1777.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1778.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1779.     public string Key {

  1780.       get { return key_; }

  1781.       set {

  1782.         key_ = pb::ProtoPreconditions.CheckNotNull(value, "value");

  1783.       }

  1784.     }

  1785. 

  1786.     /// <summary>Field number for the "value" field.</summary>

  1787.     public const int ValueFieldNumber = 2;

  1788.     private global::Tensorflow.StructuredValue value_;

  1789.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1790.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1791.     public global::Tensorflow.StructuredValue Value {

  1792.       get { return value_; }

  1793.       set {

  1794.         value_ = value;

  1795.       }

  1796.     }

  1797. 

  1798.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1799.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1800.     public override bool Equals(object other) {

  1801.       return Equals(other as PairValue);

  1802.     }

  1803. 

  1804.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1805.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1806.     public bool Equals(PairValue other) {

  1807.       if (ReferenceEquals(other, null)) {

  1808.         return false;

  1809.       }

  1810.       if (ReferenceEquals(other, this)) {

  1811.         return true;

  1812.       }

  1813.       if (Key != other.Key) return false;

  1814.       if (!object.Equals(Value, other.Value)) return false;

  1815.       return Equals(_unknownFields, other._unknownFields);

  1816.     }

  1817. 

  1818.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1819.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1820.     public override int GetHashCode() {

  1821.       int hash = 1;

  1822.       if (Key.Length != 0) hash ^= Key.GetHashCode();

  1823.       if (value_ != null) hash ^= Value.GetHashCode();

  1824.       if (_unknownFields != null) {

  1825.         hash ^= _unknownFields.GetHashCode();

  1826.       }

  1827.       return hash;

  1828.     }

  1829. 

  1830.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1831.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1832.     public override string ToString() {

  1833.       return pb::JsonFormatter.ToDiagnosticString(this);

  1834.     }

  1835. 

  1836.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1837.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1838.     public void WriteTo(pb::CodedOutputStream output) {

  1839.     #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  1840.       output.WriteRawMessage(this);

  1841.     #else

  1842.       if (Key.Length != 0) {

  1843.         output.WriteRawTag(10);

  1844.         output.WriteString(Key);

  1845.       }

  1846.       if (value_ != null) {

  1847.         output.WriteRawTag(18);

  1848.         output.WriteMessage(Value);

  1849.       }

  1850.       if (_unknownFields != null) {

  1851.         _unknownFields.WriteTo(output);

  1852.       }

  1853.     #endif

  1854.     }

  1855. 

  1856.     #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  1857.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1858.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1859.     void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {

  1860.       if (Key.Length != 0) {

  1861.         output.WriteRawTag(10);

  1862.         output.WriteString(Key);

  1863.       }

  1864.       if (value_ != null) {

  1865.         output.WriteRawTag(18);

  1866.         output.WriteMessage(Value);

  1867.       }

  1868.       if (_unknownFields != null) {

  1869.         _unknownFields.WriteTo(ref output);

  1870.       }

  1871.     }

  1872.     #endif

  1873. 

  1874.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1875.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1876.     public int CalculateSize() {

  1877.       int size = 0;

  1878.       if (Key.Length != 0) {

  1879.         size += 1 + pb::CodedOutputStream.ComputeStringSize(Key);

  1880.       }

  1881.       if (value_ != null) {

  1882.         size += 1 + pb::CodedOutputStream.ComputeMessageSize(Value);

  1883.       }

  1884.       if (_unknownFields != null) {

  1885.         size += _unknownFields.CalculateSize();

  1886.       }

  1887.       return size;

  1888.     }

  1889. 

  1890.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1891.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1892.     public void MergeFrom(PairValue other) {

  1893.       if (other == null) {

  1894.         return;

  1895.       }

  1896.       if (other.Key.Length != 0) {

  1897.         Key = other.Key;

  1898.       }

  1899.       if (other.value_ != null) {

  1900.         if (value_ == null) {

  1901.           Value = new global::Tensorflow.StructuredValue();

  1902.         }

  1903.         Value.MergeFrom(other.Value);

  1904.       }

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

  1906.     }

  1907. 

  1908.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1909.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1910.     public void MergeFrom(pb::CodedInputStream input) {

  1911.     #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  1912.       input.ReadRawMessage(this);

  1913.     #else

  1914.       uint tag;

  1915.       while ((tag = input.ReadTag()) != 0) {

  1916.         switch(tag) {

  1917.           default:

  1918.             _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);

  1919.             break;

  1920.           case 10: {

  1921.             Key = input.ReadString();

  1922.             break;

  1923.           }

  1924.           case 18: {

  1925.             if (value_ == null) {

  1926.               Value = new global::Tensorflow.StructuredValue();

  1927.             }

  1928.             input.ReadMessage(Value);

  1929.             break;

  1930.           }

  1931.         }

  1932.       }

  1933.     #endif

  1934.     }

  1935. 

  1936.     #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  1937.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1938.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1939.     void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {

  1940.       uint tag;

  1941.       while ((tag = input.ReadTag()) != 0) {

  1942.         switch(tag) {

  1943.           default:

  1944.             _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);

  1945.             break;

  1946.           case 10: {

  1947.             Key = input.ReadString();

  1948.             break;

  1949.           }

  1950.           case 18: {

  1951.             if (value_ == null) {

  1952.               Value = new global::Tensorflow.StructuredValue();

  1953.             }

  1954.             input.ReadMessage(Value);

  1955.             break;

  1956.           }

  1957.         }

  1958.       }

  1959.     }

  1960.     #endif

  1961. 

  1962.   }

  1963. 

  1964.   /// <summary>

  1965.   /// Represents Python's namedtuple.

  1966.   /// </summary>

  1967.   public sealed partial class NamedTupleValue : pb::IMessage<NamedTupleValue>

  1968.   #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  1969.       , pb::IBufferMessage

  1970.   #endif

  1971.   {

  1972.     private static readonly pb::MessageParser<NamedTupleValue> _parser = new pb::MessageParser<NamedTupleValue>(() => new NamedTupleValue());

  1973.     private pb::UnknownFieldSet _unknownFields;

  1974.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1975.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1976.     public static pb::MessageParser<NamedTupleValue> Parser { get { return _parser; } }

  1977. 

  1978.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1979.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1980.     public static pbr::MessageDescriptor Descriptor {

  1981.       get { return global::Tensorflow.StructReflection.Descriptor.MessageTypes[6]; }

  1982.     }

  1983. 

  1984.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1985.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1986.     pbr::MessageDescriptor pb::IMessage.Descriptor {

  1987.       get { return Descriptor; }

  1988.     }

  1989. 

  1990.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1991.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  1992.     public NamedTupleValue() {

  1993.       OnConstruction();

  1994.     }

  1995. 

  1996.     partial void OnConstruction();

  1997. 

  1998.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1999.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2000.     public NamedTupleValue(NamedTupleValue other) : this() {

  2001.       name_ = other.name_;

  2002.       values_ = other.values_.Clone();

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

  2004.     }

  2005. 

  2006.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2007.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2008.     public NamedTupleValue Clone() {

  2009.       return new NamedTupleValue(this);

  2010.     }

  2011. 

  2012.     /// <summary>Field number for the "name" field.</summary>

  2013.     public const int NameFieldNumber = 1;

  2014.     private string name_ = "";

  2015.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2016.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2017.     public string Name {

  2018.       get { return name_; }

  2019.       set {

  2020.         name_ = pb::ProtoPreconditions.CheckNotNull(value, "value");

  2021.       }

  2022.     }

  2023. 

  2024.     /// <summary>Field number for the "values" field.</summary>

  2025.     public const int ValuesFieldNumber = 2;

  2026.     private static readonly pb::FieldCodec<global::Tensorflow.PairValue> _repeated_values_codec

  2027.         = pb::FieldCodec.ForMessage(18, global::Tensorflow.PairValue.Parser);

  2028.     private readonly pbc::RepeatedField<global::Tensorflow.PairValue> values_ = new pbc::RepeatedField<global::Tensorflow.PairValue>();

  2029.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2030.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2031.     public pbc::RepeatedField<global::Tensorflow.PairValue> Values {

  2032.       get { return values_; }

  2033.     }

  2034. 

  2035.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2036.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2037.     public override bool Equals(object other) {

  2038.       return Equals(other as NamedTupleValue);

  2039.     }

  2040. 

  2041.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2042.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2043.     public bool Equals(NamedTupleValue other) {

  2044.       if (ReferenceEquals(other, null)) {

  2045.         return false;

  2046.       }

  2047.       if (ReferenceEquals(other, this)) {

  2048.         return true;

  2049.       }

  2050.       if (Name != other.Name) return false;

  2051.       if(!values_.Equals(other.values_)) return false;

  2052.       return Equals(_unknownFields, other._unknownFields);

  2053.     }

  2054. 

  2055.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2056.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2057.     public override int GetHashCode() {

  2058.       int hash = 1;

  2059.       if (Name.Length != 0) hash ^= Name.GetHashCode();

  2060.       hash ^= values_.GetHashCode();

  2061.       if (_unknownFields != null) {

  2062.         hash ^= _unknownFields.GetHashCode();

  2063.       }

  2064.       return hash;

  2065.     }

  2066. 

  2067.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2068.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2069.     public override string ToString() {

  2070.       return pb::JsonFormatter.ToDiagnosticString(this);

  2071.     }

  2072. 

  2073.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2074.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2075.     public void WriteTo(pb::CodedOutputStream output) {

  2076.     #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  2077.       output.WriteRawMessage(this);

  2078.     #else

  2079.       if (Name.Length != 0) {

  2080.         output.WriteRawTag(10);

  2081.         output.WriteString(Name);

  2082.       }

  2083.       values_.WriteTo(output, _repeated_values_codec);

  2084.       if (_unknownFields != null) {

  2085.         _unknownFields.WriteTo(output);

  2086.       }

  2087.     #endif

  2088.     }

  2089. 

  2090.     #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  2091.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2092.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2093.     void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {

  2094.       if (Name.Length != 0) {

  2095.         output.WriteRawTag(10);

  2096.         output.WriteString(Name);

  2097.       }

  2098.       values_.WriteTo(ref output, _repeated_values_codec);

  2099.       if (_unknownFields != null) {

  2100.         _unknownFields.WriteTo(ref output);

  2101.       }

  2102.     }

  2103.     #endif

  2104. 

  2105.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2106.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2107.     public int CalculateSize() {

  2108.       int size = 0;

  2109.       if (Name.Length != 0) {

  2110.         size += 1 + pb::CodedOutputStream.ComputeStringSize(Name);

  2111.       }

  2112.       size += values_.CalculateSize(_repeated_values_codec);

  2113.       if (_unknownFields != null) {

  2114.         size += _unknownFields.CalculateSize();

  2115.       }

  2116.       return size;

  2117.     }

  2118. 

  2119.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2120.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2121.     public void MergeFrom(NamedTupleValue other) {

  2122.       if (other == null) {

  2123.         return;

  2124.       }

  2125.       if (other.Name.Length != 0) {

  2126.         Name = other.Name;

  2127.       }

  2128.       values_.Add(other.values_);

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

  2130.     }

  2131. 

  2132.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2133.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2134.     public void MergeFrom(pb::CodedInputStream input) {

  2135.     #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  2136.       input.ReadRawMessage(this);

  2137.     #else

  2138.       uint tag;

  2139.       while ((tag = input.ReadTag()) != 0) {

  2140.         switch(tag) {

  2141.           default:

  2142.             _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);

  2143.             break;

  2144.           case 10: {

  2145.             Name = input.ReadString();

  2146.             break;

  2147.           }

  2148.           case 18: {

  2149.             values_.AddEntriesFrom(input, _repeated_values_codec);

  2150.             break;

  2151.           }

  2152.         }

  2153.       }

  2154.     #endif

  2155.     }

  2156. 

  2157.     #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  2158.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2159.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2160.     void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {

  2161.       uint tag;

  2162.       while ((tag = input.ReadTag()) != 0) {

  2163.         switch(tag) {

  2164.           default:

  2165.             _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);

  2166.             break;

  2167.           case 10: {

  2168.             Name = input.ReadString();

  2169.             break;

  2170.           }

  2171.           case 18: {

  2172.             values_.AddEntriesFrom(ref input, _repeated_values_codec);

  2173.             break;

  2174.           }

  2175.         }

  2176.       }

  2177.     }

  2178.     #endif

  2179. 

  2180.   }

  2181. 

  2182.   /// <summary>

  2183.   /// A protobuf to represent tf.TensorSpec.

  2184.   /// </summary>

  2185.   public sealed partial class TensorSpecProto : pb::IMessage<TensorSpecProto>

  2186.   #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  2187.       , pb::IBufferMessage

  2188.   #endif

  2189.   {

  2190.     private static readonly pb::MessageParser<TensorSpecProto> _parser = new pb::MessageParser<TensorSpecProto>(() => new TensorSpecProto());

  2191.     private pb::UnknownFieldSet _unknownFields;

  2192.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2193.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2194.     public static pb::MessageParser<TensorSpecProto> Parser { get { return _parser; } }

  2195. 

  2196.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2197.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2198.     public static pbr::MessageDescriptor Descriptor {

  2199.       get { return global::Tensorflow.StructReflection.Descriptor.MessageTypes[7]; }

  2200.     }

  2201. 

  2202.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2203.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2204.     pbr::MessageDescriptor pb::IMessage.Descriptor {

  2205.       get { return Descriptor; }

  2206.     }

  2207. 

  2208.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2209.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2210.     public TensorSpecProto() {

  2211.       OnConstruction();

  2212.     }

  2213. 

  2214.     partial void OnConstruction();

  2215. 

  2216.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2217.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2218.     public TensorSpecProto(TensorSpecProto other) : this() {

  2219.       name_ = other.name_;

  2220.       shape_ = other.shape_ != null ? other.shape_.Clone() : null;

  2221.       dtype_ = other.dtype_;

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

  2223.     }

  2224. 

  2225.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2226.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2227.     public TensorSpecProto Clone() {

  2228.       return new TensorSpecProto(this);

  2229.     }

  2230. 

  2231.     /// <summary>Field number for the "name" field.</summary>

  2232.     public const int NameFieldNumber = 1;

  2233.     private string name_ = "";

  2234.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2235.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2236.     public string Name {

  2237.       get { return name_; }

  2238.       set {

  2239.         name_ = pb::ProtoPreconditions.CheckNotNull(value, "value");

  2240.       }

  2241.     }

  2242. 

  2243.     /// <summary>Field number for the "shape" field.</summary>

  2244.     public const int ShapeFieldNumber = 2;

  2245.     private global::Tensorflow.TensorShapeProto shape_;

  2246.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2247.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2248.     public global::Tensorflow.TensorShapeProto Shape {

  2249.       get { return shape_; }

  2250.       set {

  2251.         shape_ = value;

  2252.       }

  2253.     }

  2254. 

  2255.     /// <summary>Field number for the "dtype" field.</summary>

  2256.     public const int DtypeFieldNumber = 3;

  2257.     private global::Tensorflow.DataType dtype_ = global::Tensorflow.DataType.DtInvalid;

  2258.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2259.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2260.     public global::Tensorflow.DataType Dtype {

  2261.       get { return dtype_; }

  2262.       set {

  2263.         dtype_ = value;

  2264.       }

  2265.     }

  2266. 

  2267.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2268.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2269.     public override bool Equals(object other) {

  2270.       return Equals(other as TensorSpecProto);

  2271.     }

  2272. 

  2273.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2274.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2275.     public bool Equals(TensorSpecProto other) {

  2276.       if (ReferenceEquals(other, null)) {

  2277.         return false;

  2278.       }

  2279.       if (ReferenceEquals(other, this)) {

  2280.         return true;

  2281.       }

  2282.       if (Name != other.Name) return false;

  2283.       if (!object.Equals(Shape, other.Shape)) return false;

  2284.       if (Dtype != other.Dtype) return false;

  2285.       return Equals(_unknownFields, other._unknownFields);

  2286.     }

  2287. 

  2288.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2289.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2290.     public override int GetHashCode() {

  2291.       int hash = 1;

  2292.       if (Name.Length != 0) hash ^= Name.GetHashCode();

  2293.       if (shape_ != null) hash ^= Shape.GetHashCode();

  2294.       if (Dtype != global::Tensorflow.DataType.DtInvalid) hash ^= Dtype.GetHashCode();

  2295.       if (_unknownFields != null) {

  2296.         hash ^= _unknownFields.GetHashCode();

  2297.       }

  2298.       return hash;

  2299.     }

  2300. 

  2301.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2302.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2303.     public override string ToString() {

  2304.       return pb::JsonFormatter.ToDiagnosticString(this);

  2305.     }

  2306. 

  2307.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2308.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2309.     public void WriteTo(pb::CodedOutputStream output) {

  2310.     #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  2311.       output.WriteRawMessage(this);

  2312.     #else

  2313.       if (Name.Length != 0) {

  2314.         output.WriteRawTag(10);

  2315.         output.WriteString(Name);

  2316.       }

  2317.       if (shape_ != null) {

  2318.         output.WriteRawTag(18);

  2319.         output.WriteMessage(Shape);

  2320.       }

  2321.       if (Dtype != global::Tensorflow.DataType.DtInvalid) {

  2322.         output.WriteRawTag(24);

  2323.         output.WriteEnum((int) Dtype);

  2324.       }

  2325.       if (_unknownFields != null) {

  2326.         _unknownFields.WriteTo(output);

  2327.       }

  2328.     #endif

  2329.     }

  2330. 

  2331.     #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  2332.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2333.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2334.     void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {

  2335.       if (Name.Length != 0) {

  2336.         output.WriteRawTag(10);

  2337.         output.WriteString(Name);

  2338.       }

  2339.       if (shape_ != null) {

  2340.         output.WriteRawTag(18);

  2341.         output.WriteMessage(Shape);

  2342.       }

  2343.       if (Dtype != global::Tensorflow.DataType.DtInvalid) {

  2344.         output.WriteRawTag(24);

  2345.         output.WriteEnum((int) Dtype);

  2346.       }

  2347.       if (_unknownFields != null) {

  2348.         _unknownFields.WriteTo(ref output);

  2349.       }

  2350.     }

  2351.     #endif

  2352. 

  2353.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2354.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2355.     public int CalculateSize() {

  2356.       int size = 0;

  2357.       if (Name.Length != 0) {

  2358.         size += 1 + pb::CodedOutputStream.ComputeStringSize(Name);

  2359.       }

  2360.       if (shape_ != null) {

  2361.         size += 1 + pb::CodedOutputStream.ComputeMessageSize(Shape);

  2362.       }

  2363.       if (Dtype != global::Tensorflow.DataType.DtInvalid) {

  2364.         size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) Dtype);

  2365.       }

  2366.       if (_unknownFields != null) {

  2367.         size += _unknownFields.CalculateSize();

  2368.       }

  2369.       return size;

  2370.     }

  2371. 

  2372.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2373.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2374.     public void MergeFrom(TensorSpecProto other) {

  2375.       if (other == null) {

  2376.         return;

  2377.       }

  2378.       if (other.Name.Length != 0) {

  2379.         Name = other.Name;

  2380.       }

  2381.       if (other.shape_ != null) {

  2382.         if (shape_ == null) {

  2383.           Shape = new global::Tensorflow.TensorShapeProto();

  2384.         }

  2385.         Shape.MergeFrom(other.Shape);

  2386.       }

  2387.       if (other.Dtype != global::Tensorflow.DataType.DtInvalid) {

  2388.         Dtype = other.Dtype;

  2389.       }

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

  2391.     }

  2392. 

  2393.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2394.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2395.     public void MergeFrom(pb::CodedInputStream input) {

  2396.     #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  2397.       input.ReadRawMessage(this);

  2398.     #else

  2399.       uint tag;

  2400.       while ((tag = input.ReadTag()) != 0) {

  2401.         switch(tag) {

  2402.           default:

  2403.             _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);

  2404.             break;

  2405.           case 10: {

  2406.             Name = input.ReadString();

  2407.             break;

  2408.           }

  2409.           case 18: {

  2410.             if (shape_ == null) {

  2411.               Shape = new global::Tensorflow.TensorShapeProto();

  2412.             }

  2413.             input.ReadMessage(Shape);

  2414.             break;

  2415.           }

  2416.           case 24: {

  2417.             Dtype = (global::Tensorflow.DataType) input.ReadEnum();

  2418.             break;

  2419.           }

  2420.         }

  2421.       }

  2422.     #endif

  2423.     }

  2424. 

  2425.     #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  2426.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2427.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2428.     void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {

  2429.       uint tag;

  2430.       while ((tag = input.ReadTag()) != 0) {

  2431.         switch(tag) {

  2432.           default:

  2433.             _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);

  2434.             break;

  2435.           case 10: {

  2436.             Name = input.ReadString();

  2437.             break;

  2438.           }

  2439.           case 18: {

  2440.             if (shape_ == null) {

  2441.               Shape = new global::Tensorflow.TensorShapeProto();

  2442.             }

  2443.             input.ReadMessage(Shape);

  2444.             break;

  2445.           }

  2446.           case 24: {

  2447.             Dtype = (global::Tensorflow.DataType) input.ReadEnum();

  2448.             break;

  2449.           }

  2450.         }

  2451.       }

  2452.     }

  2453.     #endif

  2454. 

  2455.   }

  2456. 

  2457.   /// <summary>

  2458.   /// A protobuf to represent tf.BoundedTensorSpec.

  2459.   /// </summary>

  2460.   public sealed partial class BoundedTensorSpecProto : pb::IMessage<BoundedTensorSpecProto>

  2461.   #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  2462.       , pb::IBufferMessage

  2463.   #endif

  2464.   {

  2465.     private static readonly pb::MessageParser<BoundedTensorSpecProto> _parser = new pb::MessageParser<BoundedTensorSpecProto>(() => new BoundedTensorSpecProto());

  2466.     private pb::UnknownFieldSet _unknownFields;

  2467.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2468.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2469.     public static pb::MessageParser<BoundedTensorSpecProto> Parser { get { return _parser; } }

  2470. 

  2471.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2472.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2473.     public static pbr::MessageDescriptor Descriptor {

  2474.       get { return global::Tensorflow.StructReflection.Descriptor.MessageTypes[8]; }

  2475.     }

  2476. 

  2477.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2478.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2479.     pbr::MessageDescriptor pb::IMessage.Descriptor {

  2480.       get { return Descriptor; }

  2481.     }

  2482. 

  2483.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2484.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2485.     public BoundedTensorSpecProto() {

  2486.       OnConstruction();

  2487.     }

  2488. 

  2489.     partial void OnConstruction();

  2490. 

  2491.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2492.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2493.     public BoundedTensorSpecProto(BoundedTensorSpecProto other) : this() {

  2494.       name_ = other.name_;

  2495.       shape_ = other.shape_ != null ? other.shape_.Clone() : null;

  2496.       dtype_ = other.dtype_;

  2497.       minimum_ = other.minimum_ != null ? other.minimum_.Clone() : null;

  2498.       maximum_ = other.maximum_ != null ? other.maximum_.Clone() : null;

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

  2500.     }

  2501. 

  2502.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2503.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2504.     public BoundedTensorSpecProto Clone() {

  2505.       return new BoundedTensorSpecProto(this);

  2506.     }

  2507. 

  2508.     /// <summary>Field number for the "name" field.</summary>

  2509.     public const int NameFieldNumber = 1;

  2510.     private string name_ = "";

  2511.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2512.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2513.     public string Name {

  2514.       get { return name_; }

  2515.       set {

  2516.         name_ = pb::ProtoPreconditions.CheckNotNull(value, "value");

  2517.       }

  2518.     }

  2519. 

  2520.     /// <summary>Field number for the "shape" field.</summary>

  2521.     public const int ShapeFieldNumber = 2;

  2522.     private global::Tensorflow.TensorShapeProto shape_;

  2523.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2524.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2525.     public global::Tensorflow.TensorShapeProto Shape {

  2526.       get { return shape_; }

  2527.       set {

  2528.         shape_ = value;

  2529.       }

  2530.     }

  2531. 

  2532.     /// <summary>Field number for the "dtype" field.</summary>

  2533.     public const int DtypeFieldNumber = 3;

  2534.     private global::Tensorflow.DataType dtype_ = global::Tensorflow.DataType.DtInvalid;

  2535.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2536.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2537.     public global::Tensorflow.DataType Dtype {

  2538.       get { return dtype_; }

  2539.       set {

  2540.         dtype_ = value;

  2541.       }

  2542.     }

  2543. 

  2544.     /// <summary>Field number for the "minimum" field.</summary>

  2545.     public const int MinimumFieldNumber = 4;

  2546.     private global::Tensorflow.TensorProto minimum_;

  2547.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2548.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2549.     public global::Tensorflow.TensorProto Minimum {

  2550.       get { return minimum_; }

  2551.       set {

  2552.         minimum_ = value;

  2553.       }

  2554.     }

  2555. 

  2556.     /// <summary>Field number for the "maximum" field.</summary>

  2557.     public const int MaximumFieldNumber = 5;

  2558.     private global::Tensorflow.TensorProto maximum_;

  2559.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2560.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2561.     public global::Tensorflow.TensorProto Maximum {

  2562.       get { return maximum_; }

  2563.       set {

  2564.         maximum_ = value;

  2565.       }

  2566.     }

  2567. 

  2568.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2569.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2570.     public override bool Equals(object other) {

  2571.       return Equals(other as BoundedTensorSpecProto);

  2572.     }

  2573. 

  2574.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2575.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2576.     public bool Equals(BoundedTensorSpecProto other) {

  2577.       if (ReferenceEquals(other, null)) {

  2578.         return false;

  2579.       }

  2580.       if (ReferenceEquals(other, this)) {

  2581.         return true;

  2582.       }

  2583.       if (Name != other.Name) return false;

  2584.       if (!object.Equals(Shape, other.Shape)) return false;

  2585.       if (Dtype != other.Dtype) return false;

  2586.       if (!object.Equals(Minimum, other.Minimum)) return false;

  2587.       if (!object.Equals(Maximum, other.Maximum)) return false;

  2588.       return Equals(_unknownFields, other._unknownFields);

  2589.     }

  2590. 

  2591.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2592.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2593.     public override int GetHashCode() {

  2594.       int hash = 1;

  2595.       if (Name.Length != 0) hash ^= Name.GetHashCode();

  2596.       if (shape_ != null) hash ^= Shape.GetHashCode();

  2597.       if (Dtype != global::Tensorflow.DataType.DtInvalid) hash ^= Dtype.GetHashCode();

  2598.       if (minimum_ != null) hash ^= Minimum.GetHashCode();

  2599.       if (maximum_ != null) hash ^= Maximum.GetHashCode();

  2600.       if (_unknownFields != null) {

  2601.         hash ^= _unknownFields.GetHashCode();

  2602.       }

  2603.       return hash;

  2604.     }

  2605. 

  2606.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2607.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2608.     public override string ToString() {

  2609.       return pb::JsonFormatter.ToDiagnosticString(this);

  2610.     }

  2611. 

  2612.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2613.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2614.     public void WriteTo(pb::CodedOutputStream output) {

  2615.     #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  2616.       output.WriteRawMessage(this);

  2617.     #else

  2618.       if (Name.Length != 0) {

  2619.         output.WriteRawTag(10);

  2620.         output.WriteString(Name);

  2621.       }

  2622.       if (shape_ != null) {

  2623.         output.WriteRawTag(18);

  2624.         output.WriteMessage(Shape);

  2625.       }

  2626.       if (Dtype != global::Tensorflow.DataType.DtInvalid) {

  2627.         output.WriteRawTag(24);

  2628.         output.WriteEnum((int) Dtype);

  2629.       }

  2630.       if (minimum_ != null) {

  2631.         output.WriteRawTag(34);

  2632.         output.WriteMessage(Minimum);

  2633.       }

  2634.       if (maximum_ != null) {

  2635.         output.WriteRawTag(42);

  2636.         output.WriteMessage(Maximum);

  2637.       }

  2638.       if (_unknownFields != null) {

  2639.         _unknownFields.WriteTo(output);

  2640.       }

  2641.     #endif

  2642.     }

  2643. 

  2644.     #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  2645.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2646.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2647.     void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {

  2648.       if (Name.Length != 0) {

  2649.         output.WriteRawTag(10);

  2650.         output.WriteString(Name);

  2651.       }

  2652.       if (shape_ != null) {

  2653.         output.WriteRawTag(18);

  2654.         output.WriteMessage(Shape);

  2655.       }

  2656.       if (Dtype != global::Tensorflow.DataType.DtInvalid) {

  2657.         output.WriteRawTag(24);

  2658.         output.WriteEnum((int) Dtype);

  2659.       }

  2660.       if (minimum_ != null) {

  2661.         output.WriteRawTag(34);

  2662.         output.WriteMessage(Minimum);

  2663.       }

  2664.       if (maximum_ != null) {

  2665.         output.WriteRawTag(42);

  2666.         output.WriteMessage(Maximum);

  2667.       }

  2668.       if (_unknownFields != null) {

  2669.         _unknownFields.WriteTo(ref output);

  2670.       }

  2671.     }

  2672.     #endif

  2673. 

  2674.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2675.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2676.     public int CalculateSize() {

  2677.       int size = 0;

  2678.       if (Name.Length != 0) {

  2679.         size += 1 + pb::CodedOutputStream.ComputeStringSize(Name);

  2680.       }

  2681.       if (shape_ != null) {

  2682.         size += 1 + pb::CodedOutputStream.ComputeMessageSize(Shape);

  2683.       }

  2684.       if (Dtype != global::Tensorflow.DataType.DtInvalid) {

  2685.         size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) Dtype);

  2686.       }

  2687.       if (minimum_ != null) {

  2688.         size += 1 + pb::CodedOutputStream.ComputeMessageSize(Minimum);

  2689.       }

  2690.       if (maximum_ != null) {

  2691.         size += 1 + pb::CodedOutputStream.ComputeMessageSize(Maximum);

  2692.       }

  2693.       if (_unknownFields != null) {

  2694.         size += _unknownFields.CalculateSize();

  2695.       }

  2696.       return size;

  2697.     }

  2698. 

  2699.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2700.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2701.     public void MergeFrom(BoundedTensorSpecProto other) {

  2702.       if (other == null) {

  2703.         return;

  2704.       }

  2705.       if (other.Name.Length != 0) {

  2706.         Name = other.Name;

  2707.       }

  2708.       if (other.shape_ != null) {

  2709.         if (shape_ == null) {

  2710.           Shape = new global::Tensorflow.TensorShapeProto();

  2711.         }

  2712.         Shape.MergeFrom(other.Shape);

  2713.       }

  2714.       if (other.Dtype != global::Tensorflow.DataType.DtInvalid) {

  2715.         Dtype = other.Dtype;

  2716.       }

  2717.       if (other.minimum_ != null) {

  2718.         if (minimum_ == null) {

  2719.           Minimum = new global::Tensorflow.TensorProto();

  2720.         }

  2721.         Minimum.MergeFrom(other.Minimum);

  2722.       }

  2723.       if (other.maximum_ != null) {

  2724.         if (maximum_ == null) {

  2725.           Maximum = new global::Tensorflow.TensorProto();

  2726.         }

  2727.         Maximum.MergeFrom(other.Maximum);

  2728.       }

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

  2730.     }

  2731. 

  2732.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2733.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2734.     public void MergeFrom(pb::CodedInputStream input) {

  2735.     #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  2736.       input.ReadRawMessage(this);

  2737.     #else

  2738.       uint tag;

  2739.       while ((tag = input.ReadTag()) != 0) {

  2740.         switch(tag) {

  2741.           default:

  2742.             _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);

  2743.             break;

  2744.           case 10: {

  2745.             Name = input.ReadString();

  2746.             break;

  2747.           }

  2748.           case 18: {

  2749.             if (shape_ == null) {

  2750.               Shape = new global::Tensorflow.TensorShapeProto();

  2751.             }

  2752.             input.ReadMessage(Shape);

  2753.             break;

  2754.           }

  2755.           case 24: {

  2756.             Dtype = (global::Tensorflow.DataType) input.ReadEnum();

  2757.             break;

  2758.           }

  2759.           case 34: {

  2760.             if (minimum_ == null) {

  2761.               Minimum = new global::Tensorflow.TensorProto();

  2762.             }

  2763.             input.ReadMessage(Minimum);

  2764.             break;

  2765.           }

  2766.           case 42: {

  2767.             if (maximum_ == null) {

  2768.               Maximum = new global::Tensorflow.TensorProto();

  2769.             }

  2770.             input.ReadMessage(Maximum);

  2771.             break;

  2772.           }

  2773.         }

  2774.       }

  2775.     #endif

  2776.     }

  2777. 

  2778.     #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  2779.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2780.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2781.     void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {

  2782.       uint tag;

  2783.       while ((tag = input.ReadTag()) != 0) {

  2784.         switch(tag) {

  2785.           default:

  2786.             _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);

  2787.             break;

  2788.           case 10: {

  2789.             Name = input.ReadString();

  2790.             break;

  2791.           }

  2792.           case 18: {

  2793.             if (shape_ == null) {

  2794.               Shape = new global::Tensorflow.TensorShapeProto();

  2795.             }

  2796.             input.ReadMessage(Shape);

  2797.             break;

  2798.           }

  2799.           case 24: {

  2800.             Dtype = (global::Tensorflow.DataType) input.ReadEnum();

  2801.             break;

  2802.           }

  2803.           case 34: {

  2804.             if (minimum_ == null) {

  2805.               Minimum = new global::Tensorflow.TensorProto();

  2806.             }

  2807.             input.ReadMessage(Minimum);

  2808.             break;

  2809.           }

  2810.           case 42: {

  2811.             if (maximum_ == null) {

  2812.               Maximum = new global::Tensorflow.TensorProto();

  2813.             }

  2814.             input.ReadMessage(Maximum);

  2815.             break;

  2816.           }

  2817.         }

  2818.       }

  2819.     }

  2820.     #endif

  2821. 

  2822.   }

  2823. 

  2824.   /// <summary>

  2825.   /// Represents a tf.TypeSpec

  2826.   /// </summary>

  2827.   public sealed partial class TypeSpecProto : pb::IMessage<TypeSpecProto>

  2828.   #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  2829.       , pb::IBufferMessage

  2830.   #endif

  2831.   {

  2832.     private static readonly pb::MessageParser<TypeSpecProto> _parser = new pb::MessageParser<TypeSpecProto>(() => new TypeSpecProto());

  2833.     private pb::UnknownFieldSet _unknownFields;

  2834.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2835.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2836.     public static pb::MessageParser<TypeSpecProto> Parser { get { return _parser; } }

  2837. 

  2838.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2839.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2840.     public static pbr::MessageDescriptor Descriptor {

  2841.       get { return global::Tensorflow.StructReflection.Descriptor.MessageTypes[9]; }

  2842.     }

  2843. 

  2844.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2845.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2846.     pbr::MessageDescriptor pb::IMessage.Descriptor {

  2847.       get { return Descriptor; }

  2848.     }

  2849. 

  2850.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2851.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2852.     public TypeSpecProto() {

  2853.       OnConstruction();

  2854.     }

  2855. 

  2856.     partial void OnConstruction();

  2857. 

  2858.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2859.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2860.     public TypeSpecProto(TypeSpecProto other) : this() {

  2861.       typeSpecClass_ = other.typeSpecClass_;

  2862.       typeState_ = other.typeState_ != null ? other.typeState_.Clone() : null;

  2863.       typeSpecClassName_ = other.typeSpecClassName_;

  2864.       numFlatComponents_ = other.numFlatComponents_;

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

  2866.     }

  2867. 

  2868.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2869.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2870.     public TypeSpecProto Clone() {

  2871.       return new TypeSpecProto(this);

  2872.     }

  2873. 

  2874.     /// <summary>Field number for the "type_spec_class" field.</summary>

  2875.     public const int TypeSpecClassFieldNumber = 1;

  2876.     private global::Tensorflow.TypeSpecProto.Types.TypeSpecClass typeSpecClass_ = global::Tensorflow.TypeSpecProto.Types.TypeSpecClass.Unknown;

  2877.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2878.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2879.     public global::Tensorflow.TypeSpecProto.Types.TypeSpecClass TypeSpecClass {

  2880.       get { return typeSpecClass_; }

  2881.       set {

  2882.         typeSpecClass_ = value;

  2883.       }

  2884.     }

  2885. 

  2886.     /// <summary>Field number for the "type_state" field.</summary>

  2887.     public const int TypeStateFieldNumber = 2;

  2888.     private global::Tensorflow.StructuredValue typeState_;

  2889.     /// <summary>

  2890.     /// The value returned by TypeSpec._serialize().

  2891.     /// </summary>

  2892.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2893.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2894.     public global::Tensorflow.StructuredValue TypeState {

  2895.       get { return typeState_; }

  2896.       set {

  2897.         typeState_ = value;

  2898.       }

  2899.     }

  2900. 

  2901.     /// <summary>Field number for the "type_spec_class_name" field.</summary>

  2902.     public const int TypeSpecClassNameFieldNumber = 3;

  2903.     private string typeSpecClassName_ = "";

  2904.     /// <summary>

  2905.     /// The name of the TypeSpec class.

  2906.     ///  * If type_spec_class == REGISTERED_TYPE_SPEC, the TypeSpec class is

  2907.     ///    the one registered under this name. For types registered outside

  2908.     ///    core TensorFlow by an add-on library, that library must be loaded

  2909.     ///    before this value can be deserialized by nested_structure_coder.

  2910.     ///  * If type_spec_class specifies a particular TypeSpec class, this field is

  2911.     ///    redundant with the type_spec_class enum, and is only used for error

  2912.     ///    reporting in older binaries that do not know the tupe_spec_class enum.

  2913.     /// </summary>

  2914.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2915.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2916.     public string TypeSpecClassName {

  2917.       get { return typeSpecClassName_; }

  2918.       set {

  2919.         typeSpecClassName_ = pb::ProtoPreconditions.CheckNotNull(value, "value");

  2920.       }

  2921.     }

  2922. 

  2923.     /// <summary>Field number for the "num_flat_components" field.</summary>

  2924.     public const int NumFlatComponentsFieldNumber = 4;

  2925.     private int numFlatComponents_;

  2926.     /// <summary>

  2927.     /// The number of flat tensor components required by this TypeSpec.

  2928.     /// </summary>

  2929.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2930.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2931.     public int NumFlatComponents {

  2932.       get { return numFlatComponents_; }

  2933.       set {

  2934.         numFlatComponents_ = value;

  2935.       }

  2936.     }

  2937. 

  2938.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2939.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2940.     public override bool Equals(object other) {

  2941.       return Equals(other as TypeSpecProto);

  2942.     }

  2943. 

  2944.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2945.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2946.     public bool Equals(TypeSpecProto other) {

  2947.       if (ReferenceEquals(other, null)) {

  2948.         return false;

  2949.       }

  2950.       if (ReferenceEquals(other, this)) {

  2951.         return true;

  2952.       }

  2953.       if (TypeSpecClass != other.TypeSpecClass) return false;

  2954.       if (!object.Equals(TypeState, other.TypeState)) return false;

  2955.       if (TypeSpecClassName != other.TypeSpecClassName) return false;

  2956.       if (NumFlatComponents != other.NumFlatComponents) return false;

  2957.       return Equals(_unknownFields, other._unknownFields);

  2958.     }

  2959. 

  2960.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2961.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2962.     public override int GetHashCode() {

  2963.       int hash = 1;

  2964.       if (TypeSpecClass != global::Tensorflow.TypeSpecProto.Types.TypeSpecClass.Unknown) hash ^= TypeSpecClass.GetHashCode();

  2965.       if (typeState_ != null) hash ^= TypeState.GetHashCode();

  2966.       if (TypeSpecClassName.Length != 0) hash ^= TypeSpecClassName.GetHashCode();

  2967.       if (NumFlatComponents != 0) hash ^= NumFlatComponents.GetHashCode();

  2968.       if (_unknownFields != null) {

  2969.         hash ^= _unknownFields.GetHashCode();

  2970.       }

  2971.       return hash;

  2972.     }

  2973. 

  2974.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2975.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2976.     public override string ToString() {

  2977.       return pb::JsonFormatter.ToDiagnosticString(this);

  2978.     }

  2979. 

  2980.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2981.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  2982.     public void WriteTo(pb::CodedOutputStream output) {

  2983.     #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  2984.       output.WriteRawMessage(this);

  2985.     #else

  2986.       if (TypeSpecClass != global::Tensorflow.TypeSpecProto.Types.TypeSpecClass.Unknown) {

  2987.         output.WriteRawTag(8);

  2988.         output.WriteEnum((int) TypeSpecClass);

  2989.       }

  2990.       if (typeState_ != null) {

  2991.         output.WriteRawTag(18);

  2992.         output.WriteMessage(TypeState);

  2993.       }

  2994.       if (TypeSpecClassName.Length != 0) {

  2995.         output.WriteRawTag(26);

  2996.         output.WriteString(TypeSpecClassName);

  2997.       }

  2998.       if (NumFlatComponents != 0) {

  2999.         output.WriteRawTag(32);

  3000.         output.WriteInt32(NumFlatComponents);

  3001.       }

  3002.       if (_unknownFields != null) {

  3003.         _unknownFields.WriteTo(output);

  3004.       }

  3005.     #endif

  3006.     }

  3007. 

  3008.     #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  3009.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  3010.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  3011.     void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {

  3012.       if (TypeSpecClass != global::Tensorflow.TypeSpecProto.Types.TypeSpecClass.Unknown) {

  3013.         output.WriteRawTag(8);

  3014.         output.WriteEnum((int) TypeSpecClass);

  3015.       }

  3016.       if (typeState_ != null) {

  3017.         output.WriteRawTag(18);

  3018.         output.WriteMessage(TypeState);

  3019.       }

  3020.       if (TypeSpecClassName.Length != 0) {

  3021.         output.WriteRawTag(26);

  3022.         output.WriteString(TypeSpecClassName);

  3023.       }

  3024.       if (NumFlatComponents != 0) {

  3025.         output.WriteRawTag(32);

  3026.         output.WriteInt32(NumFlatComponents);

  3027.       }

  3028.       if (_unknownFields != null) {

  3029.         _unknownFields.WriteTo(ref output);

  3030.       }

  3031.     }

  3032.     #endif

  3033. 

  3034.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  3035.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  3036.     public int CalculateSize() {

  3037.       int size = 0;

  3038.       if (TypeSpecClass != global::Tensorflow.TypeSpecProto.Types.TypeSpecClass.Unknown) {

  3039.         size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) TypeSpecClass);

  3040.       }

  3041.       if (typeState_ != null) {

  3042.         size += 1 + pb::CodedOutputStream.ComputeMessageSize(TypeState);

  3043.       }

  3044.       if (TypeSpecClassName.Length != 0) {

  3045.         size += 1 + pb::CodedOutputStream.ComputeStringSize(TypeSpecClassName);

  3046.       }

  3047.       if (NumFlatComponents != 0) {

  3048.         size += 1 + pb::CodedOutputStream.ComputeInt32Size(NumFlatComponents);

  3049.       }

  3050.       if (_unknownFields != null) {

  3051.         size += _unknownFields.CalculateSize();

  3052.       }

  3053.       return size;

  3054.     }

  3055. 

  3056.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  3057.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  3058.     public void MergeFrom(TypeSpecProto other) {

  3059.       if (other == null) {

  3060.         return;

  3061.       }

  3062.       if (other.TypeSpecClass != global::Tensorflow.TypeSpecProto.Types.TypeSpecClass.Unknown) {

  3063.         TypeSpecClass = other.TypeSpecClass;

  3064.       }

  3065.       if (other.typeState_ != null) {

  3066.         if (typeState_ == null) {

  3067.           TypeState = new global::Tensorflow.StructuredValue();

  3068.         }

  3069.         TypeState.MergeFrom(other.TypeState);

  3070.       }

  3071.       if (other.TypeSpecClassName.Length != 0) {

  3072.         TypeSpecClassName = other.TypeSpecClassName;

  3073.       }

  3074.       if (other.NumFlatComponents != 0) {

  3075.         NumFlatComponents = other.NumFlatComponents;

  3076.       }

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

  3078.     }

  3079. 

  3080.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  3081.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  3082.     public void MergeFrom(pb::CodedInputStream input) {

  3083.     #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  3084.       input.ReadRawMessage(this);

  3085.     #else

  3086.       uint tag;

  3087.       while ((tag = input.ReadTag()) != 0) {

  3088.         switch(tag) {

  3089.           default:

  3090.             _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);

  3091.             break;

  3092.           case 8: {

  3093.             TypeSpecClass = (global::Tensorflow.TypeSpecProto.Types.TypeSpecClass) input.ReadEnum();

  3094.             break;

  3095.           }

  3096.           case 18: {

  3097.             if (typeState_ == null) {

  3098.               TypeState = new global::Tensorflow.StructuredValue();

  3099.             }

  3100.             input.ReadMessage(TypeState);

  3101.             break;

  3102.           }

  3103.           case 26: {

  3104.             TypeSpecClassName = input.ReadString();

  3105.             break;

  3106.           }

  3107.           case 32: {

  3108.             NumFlatComponents = input.ReadInt32();

  3109.             break;

  3110.           }

  3111.         }

  3112.       }

  3113.     #endif

  3114.     }

  3115. 

  3116.     #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

  3117.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  3118.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  3119.     void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {

  3120.       uint tag;

  3121.       while ((tag = input.ReadTag()) != 0) {

  3122.         switch(tag) {

  3123.           default:

  3124.             _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);

  3125.             break;

  3126.           case 8: {

  3127.             TypeSpecClass = (global::Tensorflow.TypeSpecProto.Types.TypeSpecClass) input.ReadEnum();

  3128.             break;

  3129.           }

  3130.           case 18: {

  3131.             if (typeState_ == null) {

  3132.               TypeState = new global::Tensorflow.StructuredValue();

  3133.             }

  3134.             input.ReadMessage(TypeState);

  3135.             break;

  3136.           }

  3137.           case 26: {

  3138.             TypeSpecClassName = input.ReadString();

  3139.             break;

  3140.           }

  3141.           case 32: {

  3142.             NumFlatComponents = input.ReadInt32();

  3143.             break;

  3144.           }

  3145.         }

  3146.       }

  3147.     }

  3148.     #endif

  3149. 

  3150.     #region Nested types

  3151.     /// <summary>Container for nested types declared in the TypeSpecProto message type.</summary>

  3152.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  3153.     [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

  3154.     public static partial class Types {

  3155.       public enum TypeSpecClass {

  3156.         [pbr::OriginalName("UNKNOWN")] Unknown = 0,

  3157.         /// <summary>

  3158.         /// tf.SparseTensorSpec

  3159.         /// </summary>

  3160.         [pbr::OriginalName("SPARSE_TENSOR_SPEC")] SparseTensorSpec = 1,

  3161.         /// <summary>

  3162.         /// tf.IndexedSlicesSpec

  3163.         /// </summary>

  3164.         [pbr::OriginalName("INDEXED_SLICES_SPEC")] IndexedSlicesSpec = 2,

  3165.         /// <summary>

  3166.         /// tf.RaggedTensorSpec

  3167.         /// </summary>

  3168.         [pbr::OriginalName("RAGGED_TENSOR_SPEC")] RaggedTensorSpec = 3,

  3169.         /// <summary>

  3170.         /// tf.TensorArraySpec

  3171.         /// </summary>

  3172.         [pbr::OriginalName("TENSOR_ARRAY_SPEC")] TensorArraySpec = 4,

  3173.         /// <summary>

  3174.         /// tf.data.DatasetSpec

  3175.         /// </summary>

  3176.         [pbr::OriginalName("DATA_DATASET_SPEC")] DataDatasetSpec = 5,

  3177.         /// <summary>

  3178.         /// IteratorSpec from data/ops/iterator_ops.py

  3179.         /// </summary>

  3180.         [pbr::OriginalName("DATA_ITERATOR_SPEC")] DataIteratorSpec = 6,

  3181.         /// <summary>

  3182.         /// tf.OptionalSpec

  3183.         /// </summary>

  3184.         [pbr::OriginalName("OPTIONAL_SPEC")] OptionalSpec = 7,

  3185.         /// <summary>

  3186.         /// PerReplicaSpec from distribute/values.py

  3187.         /// </summary>

  3188.         [pbr::OriginalName("PER_REPLICA_SPEC")] PerReplicaSpec = 8,

  3189.         /// <summary>

  3190.         /// tf.VariableSpec

  3191.         /// </summary>

  3192.         [pbr::OriginalName("VARIABLE_SPEC")] VariableSpec = 9,

  3193.         /// <summary>

  3194.         /// RowPartitionSpec from ragged/row_partition.py

  3195.         /// </summary>

  3196.         [pbr::OriginalName("ROW_PARTITION_SPEC")] RowPartitionSpec = 10,

  3197.         /// <summary>

  3198.         /// The type registered as type_spec_class_name.

  3199.         /// </summary>

  3200.         [pbr::OriginalName("REGISTERED_TYPE_SPEC")] RegisteredTypeSpec = 12,

  3201.         /// <summary>

  3202.         /// Subclasses of tf.ExtensionType

  3203.         /// </summary>

  3204.         [pbr::OriginalName("EXTENSION_TYPE_SPEC")] ExtensionTypeSpec = 13,

  3205.       }

  3206. 

  3207.     }

  3208.     #endregion

  3209. 

  3210.   }

  3211. 

  3212.   #endregion

  3213. 

  3214. }

  3215. 

  3216. #endregion Designer generated code