context: // Generated by ProtoGen, Version=2.3.0.277, Culture=neutral, PublicKeyToken=17b3b1f090c3ea48.  DO NOT EDIT!
  #pragma warning disable 1591
  #region Designer generated code
  
  using pb = global::Google.ProtocolBuffers;
  using pbc = global::Google.ProtocolBuffers.Collections;
  using pbd = global::Google.ProtocolBuffers.Descriptors;
  using scg = global::System.Collections.Generic;
  namespace bnet.protocol {
    
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("ProtoGen", "2.3.0.277")]
    public static partial class Descriptor {
    
      #region Extension registration
      public static void RegisterAllExtensions(pb::ExtensionRegistry registry) {
      }
      #endregion
      #region Static variables
      internal static pbd::MessageDescriptor internal__static_bnet_protocol_Path__Descriptor;
      internal static pb::FieldAccess.FieldAccessorTable<global::bnet.protocol.Path, global::bnet.protocol.Path.Builder> internal__static_bnet_protocol_Path__FieldAccessorTable;
      #endregion
      #region Descriptor
      public static pbd::FileDescriptor DescriptorProp {
        get { return descriptor; }
      }
      private static pbd::FileDescriptor descriptor;
      
      static Descriptor() {
        byte[] descriptorData = global::System.Convert.FromBase64String(
            "Ch1saWIvcHJvdG9jb2wvZGVzY3JpcHRvci5wcm90bxINYm5ldC5wcm90b2Nv" + 
            "bCIXCgRQYXRoEg8KB29yZGluYWwYASADKA0=");
        pbd::FileDescriptor.InternalDescriptorAssigner assigner = delegate(pbd::FileDescriptor root) {
          descriptor = root;
          internal__static_bnet_protocol_Path__Descriptor = DescriptorProp.MessageTypes[0];
          internal__static_bnet_protocol_Path__FieldAccessorTable = 
              new pb::FieldAccess.FieldAccessorTable<global::bnet.protocol.Path, global::bnet.protocol.Path.Builder>(internal__static_bnet_protocol_Path__Descriptor,
                  new string[] { "Ordinal", });
          return null;
        };
        pbd::FileDescriptor.InternalBuildGeneratedFileFrom(descriptorData,
            new pbd::FileDescriptor[] {
            }, assigner);
      }
      #endregion
      
    }
    #region Messages
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("ProtoGen", "2.3.0.277")]
    public sealed partial class Path : pb::GeneratedMessage<Path, Path.Builder> {
      private static readonly Path defaultInstance = new Builder().BuildPartial();
      private static readonly string[] _pathFieldNames = new string[] { "ordinal" };
      private static readonly uint[] _pathFieldTags = new uint[] { 8 };
      public static Path DefaultInstance {
        get { return defaultInstance; }
      }
      
      public override Path DefaultInstanceForType {
        get { return defaultInstance; }
      }
      
      protected override Path ThisMessage {
        get { return this; }
      }
      
      public static pbd::MessageDescriptor Descriptor {
        get { return global::bnet.protocol.Descriptor.internal__static_bnet_protocol_Path__Descriptor; }
      }
      
      protected override pb::FieldAccess.FieldAccessorTable<Path, Path.Builder> InternalFieldAccessors {
        get { return global::bnet.protocol.Descriptor.internal__static_bnet_protocol_Path__FieldAccessorTable; }
      }
      
      public const int OrdinalFieldNumber = 1;
      private pbc::PopsicleList<uint> ordinal_ = new pbc::PopsicleList<uint>();
      public scg::IList<uint> OrdinalList {
        get { return pbc::Lists.AsReadOnly(ordinal_); }
      }
      public int OrdinalCount {
        get { return ordinal_.Count; }
      }
      public uint GetOrdinal(int index) {
        return ordinal_[index];
      }
      
      public override bool IsInitialized {
        get {
          return true;
        }
      }
      
      public override void WriteTo(pb::ICodedOutputStream output) {
        int size = SerializedSize;
        string[] field_names = _pathFieldNames;
        if (ordinal_.Count > 0) {
          output.WriteUInt32Array(1, field_names[0], ordinal_);
        }
        UnknownFields.WriteTo(output);
      }
      
      private int memoizedSerializedSize = -1;
      public override int SerializedSize {
        get {
          int size = memoizedSerializedSize;
          if (size != -1) return size;
          
          size = 0;
          {
            int dataSize = 0;
            foreach (uint element in OrdinalList) {
              dataSize += pb::CodedOutputStream.ComputeUInt32SizeNoTag(element);
            }
            size += dataSize;
            size += 1 * ordinal_.Count;
          }
          size += UnknownFields.SerializedSize;
          memoizedSerializedSize = size;
          return size;
        }
      }
      
      public static Path ParseFrom(pb::ByteString data) {
        return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
      }
      public static Path ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {
        return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
      }
      public static Path ParseFrom(byte[] data) {
        return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
      }
      public static Path ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {
        return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
      }
      public static Path ParseFrom(global::System.IO.Stream input) {
        return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
      }
      public static Path ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
        return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
      }
      public static Path ParseDelimitedFrom(global::System.IO.Stream input) {
        return CreateBuilder().MergeDelimitedFrom(input).BuildParsed();
      }
      public static Path ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
        return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed();
      }
      public static Path ParseFrom(pb::ICodedInputStream input) {
        return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
      }
      public static Path ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
        return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
      }
      public static Builder CreateBuilder() { return new Builder(); }
      public override Builder ToBuilder() { return CreateBuilder(this); }
      public override Builder CreateBuilderForType() { return new Builder(); }
      public static Builder CreateBuilder(Path prototype) {
        return (Builder) new Builder().MergeFrom(prototype);
      }
      
      [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
      [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
      [global::System.CodeDom.Compiler.GeneratedCodeAttribute("ProtoGen", "2.3.0.277")]
      public sealed partial class Builder : pb::GeneratedBuilder<Path, Builder> {
        protected override Builder ThisBuilder {
          get { return this; }
        }
        public Builder() {}
        
        Path result = new Path();
        
        protected override Path MessageBeingBuilt {
          get { return result; }
        }
        
        public override Builder Clear() {
          result = new Path();
          return this;
        }
        
        public override Builder Clone() {
          return new Builder().MergeFrom(result);
        }
        
        public override pbd::MessageDescriptor DescriptorForType {
          get { return global::bnet.protocol.Path.Descriptor; }
        }
        
        public override Path DefaultInstanceForType {
          get { return global::bnet.protocol.Path.DefaultInstance; }
        }
        
        public override Path BuildPartial() {
          if (result == null) {
            throw new global::System.InvalidOperationException("build() has already been called on this Builder");
          }
          result.ordinal_.MakeReadOnly();
          Path returnMe = result;
          result = null;
          return returnMe;
        }
        
        public override Builder MergeFrom(pb::IMessage other) {
          if (other is Path) {
            return MergeFrom((Path) other);
          } else {
            base.MergeFrom(other);
            return this;
          }
        }
        
        public override Builder MergeFrom(Path other) {
          if (other == global::bnet.protocol.Path.DefaultInstance) return this;
          if (other.ordinal_.Count != 0) {
            base.AddRange(other.ordinal_, result.ordinal_);
          }
          this.MergeUnknownFields(other.UnknownFields);
          return this;
        }
        
        public override Builder MergeFrom(pb::ICodedInputStream input) {
          return MergeFrom(input, pb::ExtensionRegistry.Empty);
        }
        
        public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
          pb::UnknownFieldSet.Builder unknownFields = null;
          uint tag;
          string field_name;
          while (input.ReadTag(out tag, out field_name)) {
            if(tag == 0 && field_name != null) {
              int field_ordinal = global::System.Array.BinarySearch(_pathFieldNames, field_name, global::System.StringComparer.Ordinal);
              if(field_ordinal >= 0)
  
gt:               tag = _pathFieldTags[field_ordinal];