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

using pb = global::Google.ProtocolBuffers;
using pbc = global::Google.ProtocolBuffers.Collections;
using pbd = global::Google.ProtocolBuffers.Descriptors;
using scg = global::System.Collections.Generic;
namespace Sirikata.PB._PBJ_Internal {
  
  public static partial class Test {
  
    #region Extension registration
    public static void RegisterAllExtensions(pb::ExtensionRegistry registry) {
      registry.Add(global::Sirikata.PB._PBJ_Internal.Test.Extensionbbox);
      registry.Add(global::Sirikata.PB._PBJ_Internal.Test.Extensionvector);
    }
    #endregion
    #region Extensions
    public const int ExtensionbboxFieldNumber = 100;
    public static pb::GeneratedExtensionBase<scg::IList<float>> Extensionbbox;
    public const int ExtensionvectorFieldNumber = 101;
    public static pb::GeneratedExtensionBase<scg::IList<float>> Extensionvector;
    #endregion
    
    #region Static variables
    internal static pbd::MessageDescriptor internal__static_Sirikata_PB__PBJ_Internal_ExternalMessage__Descriptor;
    internal static pb::FieldAccess.FieldAccessorTable<global::Sirikata.PB._PBJ_Internal.ExternalMessage, global::Sirikata.PB._PBJ_Internal.ExternalMessage.Builder> internal__static_Sirikata_PB__PBJ_Internal_ExternalMessage__FieldAccessorTable;
    internal static pbd::MessageDescriptor internal__static_Sirikata_PB__PBJ_Internal_ExternalMessage_SubMessage__Descriptor;
    internal static pb::FieldAccess.FieldAccessorTable<global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage, global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage.Builder> internal__static_Sirikata_PB__PBJ_Internal_ExternalMessage_SubMessage__FieldAccessorTable;
    internal static pbd::MessageDescriptor internal__static_Sirikata_PB__PBJ_Internal_TestMessage__Descriptor;
    internal static pb::FieldAccess.FieldAccessorTable<global::Sirikata.PB._PBJ_Internal.TestMessage, global::Sirikata.PB._PBJ_Internal.TestMessage.Builder> internal__static_Sirikata_PB__PBJ_Internal_TestMessage__FieldAccessorTable;
    internal static pbd::MessageDescriptor internal__static_Sirikata_PB__PBJ_Internal_TestMessage_SubMessage__Descriptor;
    internal static pb::FieldAccess.FieldAccessorTable<global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage, global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage.Builder> internal__static_Sirikata_PB__PBJ_Internal_TestMessage_SubMessage__FieldAccessorTable;
    #endregion
    #region Descriptor
    public static pbd::FileDescriptor Descriptor {
      get { return descriptor; }
    }
    private static pbd::FileDescriptor descriptor;
    
    static Test() {
      byte[] descriptorData = global::System.Convert.FromBase64String(
          "CgpUZXN0LnByb3RvEhlTaXJpa2F0YS5QQi5fUEJKX0ludGVybmFsIuwCCg9F" + 
          "eHRlcm5hbE1lc3NhZ2USFQoHaXNfdHJ1ZRgoIAEoCDoEdHJ1ZRIPCgN2MmYY" + 
          "AiADKAJCAhABEkYKB3N1Yl9tZXMYHiABKAsyNS5TaXJpa2F0YS5QQi5fUEJK" + 
          "X0ludGVybmFsLkV4dGVybmFsTWVzc2FnZS5TdWJNZXNzYWdlEkkKCnN1Ym1l" + 
          "c3NlcnMYHyADKAsyNS5TaXJpa2F0YS5QQi5fUEJKX0ludGVybmFsLkV4dGVy" + 
          "bmFsTWVzc2FnZS5TdWJNZXNzYWdlEgsKA3NoYRggIAEoDBIMCgRzaGFzGCEg" + 
          "AygMEg8KA3YzZhgEIAMoAkICEAESEAoEdjNmZhgFIAMoAkICEAEaYAoKU3Vi" + 
          "TWVzc2FnZRIPCgdzdWJ1dWlkGAEgASgMEhUKCXN1YnZlY3RvchgCIAMoAUIC" + 
          "EAESEwoLc3ViZHVyYXRpb24YAyABKBASFQoJc3Vibm9ybWFsGAQgAygCQgIQ" + 
          "ASLmCAoLVGVzdE1lc3NhZ2USEQoDeHhkGBQgASgBOgQxMC4zEgsKA3h4ZhgV" + 
          "IAEoAhINCgV4eHUzMhgWIAEoDRILCgN4eHMYFyABKAkSCwoDeHhiGBggASgM" + 
          "EgwKBHh4c3MYGSADKAkSDAoEeHhiYhgaIAMoDBIQCgR4eGZmGBsgAygCQgIQ" + 
          "ARIQCgR4eG5uGB0gAygCQgIQARIMCgR4eGZyGBwgAigCEg0KAW4YASADKAJC" + 
          "AhABEg8KA3YyZhgCIAMoAkICEAESDwoDdjJkGAMgAygBQgIQARIPCgN2M2YY" + 
          "BCADKAJCAhABEg8KA3YzZBgFIAMoAUICEAESDwoDdjRmGAYgAygCQgIQARIP" + 
          "CgN2NGQYByADKAFCAhABEg0KAXEYCCADKAJCAhABEgkKAXUYCSABKAwSCQoB" + 
          "YRgKIAEoAhIJCgF0GAsgASgGEgkKAWQYDCABKBASCwoDZjMyGA0gASgNEgsK" + 
          "A2Y2NBgOIAEoBBIPCgNic2YYDyADKAJCAhABEg8KA2JzZBgQIAMoAUICEAES" + 
          "DwoDYmJmGBEgAygCQgIQARIPCgNiYmQYEiADKAFCAhABEjoKA2UzMhgTIAEo" + 
          "DjItLlNpcmlrYXRhLlBCLl9QQkpfSW50ZXJuYWwuVGVzdE1lc3NhZ2UuRW51" + 
          "bTMyEkEKBnN1Ym1lcxgeIAEoCzIxLlNpcmlrYXRhLlBCLl9QQkpfSW50ZXJu" + 
          "YWwuVGVzdE1lc3NhZ2UuU3ViTWVzc2FnZRJFCgpzdWJtZXNzZXJzGB8gAygL" + 
          "MjEuU2lyaWthdGEuUEIuX1BCSl9JbnRlcm5hbC5UZXN0TWVzc2FnZS5TdWJN" + 
          "ZXNzYWdlEgsKA3NoYRggIAEoDBIMCgRzaGFzGCEgAygMEjoKBmV4dG1lcxgi" + 
          "IAEoCzIqLlNpcmlrYXRhLlBCLl9QQkpfSW50ZXJuYWwuRXh0ZXJuYWxNZXNz" + 
          "YWdlEj4KCmV4dG1lc3NlcnMYIyADKAsyKi5TaXJpa2F0YS5QQi5fUEJKX0lu" + 
          "dGVybmFsLkV4dGVybmFsTWVzc2FnZRI9CglleHRtZXNzZXIYJCACKAsyKi5T" + 
          "aXJpa2F0YS5QQi5fUEJKX0ludGVybmFsLkV4dGVybmFsTWVzc2FnZRpgCgpT" + 
          "dWJNZXNzYWdlEg8KB3N1YnV1aWQYASABKAwSFQoJc3VidmVjdG9yGAIgAygB" + 
          "QgIQARITCgtzdWJkdXJhdGlvbhgDIAEoEBIVCglzdWJub3JtYWwYBCADKAJC" + 
          "AhABIjUKCEZsYWdzZjMyEgwKCFVOSVZFUlNBEAASBgoCV0UQARIJCgVJTUFH" + 
          "RRACEggKBExPQ0EQAyI5CghGbGFnc2Y2NBINCglVTklWRVJTQUwQABIHCgNX" + 
          "RUIQARIKCgZJTUFHRVMQAhIJCgVMT0NBTBADIjsKBkVudW0zMhIOCgpVTklW" + 
          "RVJTQUwxEAASCAoEV0VCMRABEgsKB0lNQUdFUzEQAhIKCgZMT0NBTDEQAyoF" + 
          "CGQQyAE6QQoNZXh0ZW5zaW9uYmJveBImLlNpcmlrYXRhLlBCLl9QQkpfSW50" + 
          "ZXJuYWwuVGVzdE1lc3NhZ2UYZCADKAJCAhABOkMKD2V4dGVuc2lvbnZlY3Rv" + 
          "chImLlNpcmlrYXRhLlBCLl9QQkpfSW50ZXJuYWwuVGVzdE1lc3NhZ2UYZSAD" + 
          "KAJCAhAB");
      pbd::FileDescriptor.InternalDescriptorAssigner assigner = delegate(pbd::FileDescriptor root) {
        descriptor = root;
        internal__static_Sirikata_PB__PBJ_Internal_ExternalMessage__Descriptor = Descriptor.MessageTypes[0];
        internal__static_Sirikata_PB__PBJ_Internal_ExternalMessage__FieldAccessorTable = 
            new pb::FieldAccess.FieldAccessorTable<global::Sirikata.PB._PBJ_Internal.ExternalMessage, global::Sirikata.PB._PBJ_Internal.ExternalMessage.Builder>(internal__static_Sirikata_PB__PBJ_Internal_ExternalMessage__Descriptor,
                new string[] { "IsTrue", "V2F", "SubMes", "Submessers", "Sha", "Shas", "V3F", "V3Ff", });
        internal__static_Sirikata_PB__PBJ_Internal_ExternalMessage_SubMessage__Descriptor = internal__static_Sirikata_PB__PBJ_Internal_ExternalMessage__Descriptor.NestedTypes[0];
        internal__static_Sirikata_PB__PBJ_Internal_ExternalMessage_SubMessage__FieldAccessorTable = 
            new pb::FieldAccess.FieldAccessorTable<global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage, global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage.Builder>(internal__static_Sirikata_PB__PBJ_Internal_ExternalMessage_SubMessage__Descriptor,
                new string[] { "Subuuid", "Subvector", "Subduration", "Subnormal", });
        internal__static_Sirikata_PB__PBJ_Internal_TestMessage__Descriptor = Descriptor.MessageTypes[1];
        internal__static_Sirikata_PB__PBJ_Internal_TestMessage__FieldAccessorTable = 
            new pb::FieldAccess.FieldAccessorTable<global::Sirikata.PB._PBJ_Internal.TestMessage, global::Sirikata.PB._PBJ_Internal.TestMessage.Builder>(internal__static_Sirikata_PB__PBJ_Internal_TestMessage__Descriptor,
                new string[] { "Xxd", "Xxf", "Xxu32", "Xxs", "Xxb", "Xxss", "Xxbb", "Xxff", "Xxnn", "Xxfr", "N", "V2F", "V2D", "V3F", "V3D", "V4F", "V4D", "Q", "U", "A", "T", "D", "F32", "F64", "Bsf", "Bsd", "Bbf", "Bbd", "E32", "Submes", "Submessers", "Sha", "Shas", "Extmes", "Extmessers", "Extmesser", });
        internal__static_Sirikata_PB__PBJ_Internal_TestMessage_SubMessage__Descriptor = internal__static_Sirikata_PB__PBJ_Internal_TestMessage__Descriptor.NestedTypes[0];
        internal__static_Sirikata_PB__PBJ_Internal_TestMessage_SubMessage__FieldAccessorTable = 
            new pb::FieldAccess.FieldAccessorTable<global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage, global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage.Builder>(internal__static_Sirikata_PB__PBJ_Internal_TestMessage_SubMessage__Descriptor,
                new string[] { "Subuuid", "Subvector", "Subduration", "Subnormal", });
        global::Sirikata.PB._PBJ_Internal.Test.Extensionbbox = pb::GeneratedRepeatExtension<float>.CreateInstance(global::Sirikata.PB._PBJ_Internal.Test.Descriptor.Extensions[0]);
        global::Sirikata.PB._PBJ_Internal.Test.Extensionvector = pb::GeneratedRepeatExtension<float>.CreateInstance(global::Sirikata.PB._PBJ_Internal.Test.Descriptor.Extensions[1]);
        return null;
      };
      pbd::FileDescriptor.InternalBuildGeneratedFileFrom(descriptorData,
          new pbd::FileDescriptor[] {
          }, assigner);
    }
    #endregion
    
  }
  #region Messages
  public sealed partial class ExternalMessage : pb::GeneratedMessage<ExternalMessage, ExternalMessage.Builder> {
    private static readonly ExternalMessage defaultInstance = new Builder().BuildPartial();
    public static ExternalMessage DefaultInstance {
      get { return defaultInstance; }
    }
    
    public override ExternalMessage DefaultInstanceForType {
      get { return defaultInstance; }
    }
    
    protected override ExternalMessage ThisMessage {
      get { return this; }
    }
    
    public static pbd::MessageDescriptor Descriptor {
      get { return global::Sirikata.PB._PBJ_Internal.Test.internal__static_Sirikata_PB__PBJ_Internal_ExternalMessage__Descriptor; }
    }
    
    protected override pb::FieldAccess.FieldAccessorTable<ExternalMessage, ExternalMessage.Builder> InternalFieldAccessors {
      get { return global::Sirikata.PB._PBJ_Internal.Test.internal__static_Sirikata_PB__PBJ_Internal_ExternalMessage__FieldAccessorTable; }
    }
    
    #region Nested types
    public static class Types {
      public sealed partial class SubMessage : pb::GeneratedMessage<SubMessage, SubMessage.Builder> {
        private static readonly SubMessage defaultInstance = new Builder().BuildPartial();
        public static SubMessage DefaultInstance {
          get { return defaultInstance; }
        }
        
        public override SubMessage DefaultInstanceForType {
          get { return defaultInstance; }
        }
        
        protected override SubMessage ThisMessage {
          get { return this; }
        }
        
        public static pbd::MessageDescriptor Descriptor {
          get { return global::Sirikata.PB._PBJ_Internal.Test.internal__static_Sirikata_PB__PBJ_Internal_ExternalMessage_SubMessage__Descriptor; }
        }
        
        protected override pb::FieldAccess.FieldAccessorTable<SubMessage, SubMessage.Builder> InternalFieldAccessors {
          get { return global::Sirikata.PB._PBJ_Internal.Test.internal__static_Sirikata_PB__PBJ_Internal_ExternalMessage_SubMessage__FieldAccessorTable; }
        }
        
        public const int SubuuidFieldNumber = 1;
        private bool hasSubuuid;
        private pb::ByteString subuuid_ = pb::ByteString.Empty;
        public bool HasSubuuid {
          get { return hasSubuuid; }
        }
        public pb::ByteString Subuuid {
          get { return subuuid_; }
        }
        
        public const int SubvectorFieldNumber = 2;
        private int subvectorMemoizedSerializedSize;
        private pbc::PopsicleList<double> subvector_ = new pbc::PopsicleList<double>();
        public scg::IList<double> SubvectorList {
          get { return pbc::Lists.AsReadOnly(subvector_); }
        }
        public int SubvectorCount {
          get { return subvector_.Count; }
        }
        public double GetSubvector(int index) {
          return subvector_[index];
        }
        
        public const int SubdurationFieldNumber = 3;
        private bool hasSubduration;
        private long subduration_ = 0;
        public bool HasSubduration {
          get { return hasSubduration; }
        }
        public long Subduration {
          get { return subduration_; }
        }
        
        public const int SubnormalFieldNumber = 4;
        private int subnormalMemoizedSerializedSize;
        private pbc::PopsicleList<float> subnormal_ = new pbc::PopsicleList<float>();
        public scg::IList<float> SubnormalList {
          get { return pbc::Lists.AsReadOnly(subnormal_); }
        }
        public int SubnormalCount {
          get { return subnormal_.Count; }
        }
        public float GetSubnormal(int index) {
          return subnormal_[index];
        }
        
        public override bool IsInitialized {
          get {
            return true;
          }
        }
        
        public override void WriteTo(pb::CodedOutputStream output) {
          if (HasSubuuid) {
            output.WriteBytes(1, Subuuid);
          }
          if (subvector_.Count > 0) {
            output.WriteRawVarint32(18);
            output.WriteRawVarint32((uint) subvectorMemoizedSerializedSize);
            foreach (double element in subvector_) {
              output.WriteDoubleNoTag(element);
            }
          }
          if (HasSubduration) {
            output.WriteSFixed64(3, Subduration);
          }
          if (subnormal_.Count > 0) {
            output.WriteRawVarint32(34);
            output.WriteRawVarint32((uint) subnormalMemoizedSerializedSize);
            foreach (float element in subnormal_) {
              output.WriteFloatNoTag(element);
            }
          }
          UnknownFields.WriteTo(output);
        }
        
        private int memoizedSerializedSize = -1;
        public override int SerializedSize {
          get {
            int size = memoizedSerializedSize;
            if (size != -1) return size;
            
            size = 0;
            if (HasSubuuid) {
              size += pb::CodedOutputStream.ComputeBytesSize(1, Subuuid);
            }
            {
              int dataSize = 0;
              dataSize = 8 * subvector_.Count;
              size += dataSize;
              if (subvector_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize);
              subvectorMemoizedSerializedSize = dataSize;
            }
            if (HasSubduration) {
              size += pb::CodedOutputStream.ComputeSFixed64Size(3, Subduration);
            }
            {
              int dataSize = 0;
              dataSize = 4 * subnormal_.Count;
              size += dataSize;
              if (subnormal_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize);
              subnormalMemoizedSerializedSize = dataSize;
            }
            size += UnknownFields.SerializedSize;
            memoizedSerializedSize = size;
            return size;
          }
        }
        
        public static SubMessage ParseFrom(pb::ByteString data) {
          return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
        }
        public static SubMessage ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {
          return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
        }
        public static SubMessage ParseFrom(byte[] data) {
          return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
        }
        public static SubMessage ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {
          return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
        }
        public static SubMessage ParseFrom(global::System.IO.Stream input) {
          return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
        }
        public static SubMessage ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
          return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
        }
        public static SubMessage ParseDelimitedFrom(global::System.IO.Stream input) {
          return CreateBuilder().MergeDelimitedFrom(input).BuildParsed();
        }
        public static SubMessage ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
          return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed();
        }
        public static SubMessage ParseFrom(pb::CodedInputStream input) {
          return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
        }
        public static SubMessage ParseFrom(pb::CodedInputStream 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(SubMessage prototype) {
          return (Builder) new Builder().MergeFrom(prototype);
        }
        
        public sealed partial class Builder : pb::GeneratedBuilder<SubMessage, Builder> {
          protected override Builder ThisBuilder {
            get { return this; }
          }
          public Builder() {}
          
          SubMessage result = new SubMessage();
          
          protected override SubMessage MessageBeingBuilt {
            get { return result; }
          }
          
          public override Builder Clear() {
            result = new SubMessage();
            return this;
          }
          
          public override Builder Clone() {
            return new Builder().MergeFrom(result);
          }
          
          public override pbd::MessageDescriptor DescriptorForType {
            get { return global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage.Descriptor; }
          }
          
          public override SubMessage DefaultInstanceForType {
            get { return global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage.DefaultInstance; }
          }
          
          public override SubMessage BuildPartial() {
            if (result == null) {
              throw new global::System.InvalidOperationException("build() has already been called on this Builder");
            }
            result.subvector_.MakeReadOnly();
            result.subnormal_.MakeReadOnly();
            SubMessage returnMe = result;
            result = null;
            return returnMe;
          }
          
          public override Builder MergeFrom(pb::IMessage other) {
            if (other is SubMessage) {
              return MergeFrom((SubMessage) other);
            } else {
              base.MergeFrom(other);
              return this;
            }
          }
          
          public override Builder MergeFrom(SubMessage other) {
            if (other == global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage.DefaultInstance) return this;
            if (other.HasSubuuid) {
              Subuuid = other.Subuuid;
            }
            if (other.subvector_.Count != 0) {
              base.AddRange(other.subvector_, result.subvector_);
            }
            if (other.HasSubduration) {
              Subduration = other.Subduration;
            }
            if (other.subnormal_.Count != 0) {
              base.AddRange(other.subnormal_, result.subnormal_);
            }
            this.MergeUnknownFields(other.UnknownFields);
            return this;
          }
          
          public override Builder MergeFrom(pb::CodedInputStream input) {
            return MergeFrom(input, pb::ExtensionRegistry.Empty);
          }
          
          public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
            pb::UnknownFieldSet.Builder unknownFields = null;
            while (true) {
              uint tag = input.ReadTag();
              switch (tag) {
                case 0: {
                  if (unknownFields != null) {
                    this.UnknownFields = unknownFields.Build();
                  }
                  return this;
                }
                default: {
                  if (pb::WireFormat.IsEndGroupTag(tag)) {
                    if (unknownFields != null) {
                      this.UnknownFields = unknownFields.Build();
                    }
                    return this;
                  }
                  if (unknownFields == null) {
                    unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
                  }
                  ParseUnknownField(input, unknownFields, extensionRegistry, tag);
                  break;
                }
                case 10: {
                  Subuuid = input.ReadBytes();
                  break;
                }
                case 18: {
                  int length = input.ReadInt32();
                  int limit = input.PushLimit(length);
                  while (!input.ReachedLimit) {
                    AddSubvector(input.ReadDouble());
                  }
                  input.PopLimit(limit);
                  break;
                }
                case 25: {
                  Subduration = input.ReadSFixed64();
                  break;
                }
                case 34: {
                  int length = input.ReadInt32();
                  int limit = input.PushLimit(length);
                  while (!input.ReachedLimit) {
                    AddSubnormal(input.ReadFloat());
                  }
                  input.PopLimit(limit);
                  break;
                }
              }
            }
          }
          
          
          public bool HasSubuuid {
            get { return result.HasSubuuid; }
          }
          public pb::ByteString Subuuid {
            get { return result.Subuuid; }
            set { SetSubuuid(value); }
          }
          public Builder SetSubuuid(pb::ByteString value) {
            pb::ThrowHelper.ThrowIfNull(value, "value");
            result.hasSubuuid = true;
            result.subuuid_ = value;
            return this;
          }
          public Builder ClearSubuuid() {
            result.hasSubuuid = false;
            result.subuuid_ = pb::ByteString.Empty;
            return this;
          }
          
          public pbc::IPopsicleList<double> SubvectorList {
            get { return result.subvector_; }
          }
          public int SubvectorCount {
            get { return result.SubvectorCount; }
          }
          public double GetSubvector(int index) {
            return result.GetSubvector(index);
          }
          public Builder SetSubvector(int index, double value) {
            result.subvector_[index] = value;
            return this;
          }
          public Builder AddSubvector(double value) {
            result.subvector_.Add(value);
            return this;
          }
          public Builder AddRangeSubvector(scg::IEnumerable<double> values) {
            base.AddRange(values, result.subvector_);
            return this;
          }
          public Builder ClearSubvector() {
            result.subvector_.Clear();
            return this;
          }
          
          public bool HasSubduration {
            get { return result.HasSubduration; }
          }
          public long Subduration {
            get { return result.Subduration; }
            set { SetSubduration(value); }
          }
          public Builder SetSubduration(long value) {
            result.hasSubduration = true;
            result.subduration_ = value;
            return this;
          }
          public Builder ClearSubduration() {
            result.hasSubduration = false;
            result.subduration_ = 0;
            return this;
          }
          
          public pbc::IPopsicleList<float> SubnormalList {
            get { return result.subnormal_; }
          }
          public int SubnormalCount {
            get { return result.SubnormalCount; }
          }
          public float GetSubnormal(int index) {
            return result.GetSubnormal(index);
          }
          public Builder SetSubnormal(int index, float value) {
            result.subnormal_[index] = value;
            return this;
          }
          public Builder AddSubnormal(float value) {
            result.subnormal_.Add(value);
            return this;
          }
          public Builder AddRangeSubnormal(scg::IEnumerable<float> values) {
            base.AddRange(values, result.subnormal_);
            return this;
          }
          public Builder ClearSubnormal() {
            result.subnormal_.Clear();
            return this;
          }
        }
        static SubMessage() {
          object.ReferenceEquals(global::Sirikata.PB._PBJ_Internal.Test.Descriptor, null);
        }
      }
      
    }
    #endregion
    
    public const int IsTrueFieldNumber = 40;
    private bool hasIsTrue;
    private bool isTrue_ = true;
    public bool HasIsTrue {
      get { return hasIsTrue; }
    }
    public bool IsTrue {
      get { return isTrue_; }
    }
    
    public const int V2FFieldNumber = 2;
    private int v2FMemoizedSerializedSize;
    private pbc::PopsicleList<float> v2F_ = new pbc::PopsicleList<float>();
    public scg::IList<float> V2FList {
      get { return pbc::Lists.AsReadOnly(v2F_); }
    }
    public int V2FCount {
      get { return v2F_.Count; }
    }
    public float GetV2F(int index) {
      return v2F_[index];
    }
    
    public const int SubMesFieldNumber = 30;
    private bool hasSubMes;
    private global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage subMes_ = global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage.DefaultInstance;
    public bool HasSubMes {
      get { return hasSubMes; }
    }
    public global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage SubMes {
      get { return subMes_; }
    }
    
    public const int SubmessersFieldNumber = 31;
    private pbc::PopsicleList<global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage> submessers_ = new pbc::PopsicleList<global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage>();
    public scg::IList<global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage> SubmessersList {
      get { return submessers_; }
    }
    public int SubmessersCount {
      get { return submessers_.Count; }
    }
    public global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage GetSubmessers(int index) {
      return submessers_[index];
    }
    
    public const int ShaFieldNumber = 32;
    private bool hasSha;
    private pb::ByteString sha_ = pb::ByteString.Empty;
    public bool HasSha {
      get { return hasSha; }
    }
    public pb::ByteString Sha {
      get { return sha_; }
    }
    
    public const int ShasFieldNumber = 33;
    private pbc::PopsicleList<pb::ByteString> shas_ = new pbc::PopsicleList<pb::ByteString>();
    public scg::IList<pb::ByteString> ShasList {
      get { return pbc::Lists.AsReadOnly(shas_); }
    }
    public int ShasCount {
      get { return shas_.Count; }
    }
    public pb::ByteString GetShas(int index) {
      return shas_[index];
    }
    
    public const int V3FFieldNumber = 4;
    private int v3FMemoizedSerializedSize;
    private pbc::PopsicleList<float> v3F_ = new pbc::PopsicleList<float>();
    public scg::IList<float> V3FList {
      get { return pbc::Lists.AsReadOnly(v3F_); }
    }
    public int V3FCount {
      get { return v3F_.Count; }
    }
    public float GetV3F(int index) {
      return v3F_[index];
    }
    
    public const int V3FfFieldNumber = 5;
    private int v3FfMemoizedSerializedSize;
    private pbc::PopsicleList<float> v3Ff_ = new pbc::PopsicleList<float>();
    public scg::IList<float> V3FfList {
      get { return pbc::Lists.AsReadOnly(v3Ff_); }
    }
    public int V3FfCount {
      get { return v3Ff_.Count; }
    }
    public float GetV3Ff(int index) {
      return v3Ff_[index];
    }
    
    public override bool IsInitialized {
      get {
        return true;
      }
    }
    
    public override void WriteTo(pb::CodedOutputStream output) {
      if (v2F_.Count > 0) {
        output.WriteRawVarint32(18);
        output.WriteRawVarint32((uint) v2FMemoizedSerializedSize);
        foreach (float element in v2F_) {
          output.WriteFloatNoTag(element);
        }
      }
      if (v3F_.Count > 0) {
        output.WriteRawVarint32(34);
        output.WriteRawVarint32((uint) v3FMemoizedSerializedSize);
        foreach (float element in v3F_) {
          output.WriteFloatNoTag(element);
        }
      }
      if (v3Ff_.Count > 0) {
        output.WriteRawVarint32(42);
        output.WriteRawVarint32((uint) v3FfMemoizedSerializedSize);
        foreach (float element in v3Ff_) {
          output.WriteFloatNoTag(element);
        }
      }
      if (HasSubMes) {
        output.WriteMessage(30, SubMes);
      }
      foreach (global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage element in SubmessersList) {
        output.WriteMessage(31, element);
      }
      if (HasSha) {
        output.WriteBytes(32, Sha);
      }
      if (shas_.Count > 0) {
        foreach (pb::ByteString element in shas_) {
          output.WriteBytes(33, element);
        }
      }
      if (HasIsTrue) {
        output.WriteBool(40, IsTrue);
      }
      UnknownFields.WriteTo(output);
    }
    
    private int memoizedSerializedSize = -1;
    public override int SerializedSize {
      get {
        int size = memoizedSerializedSize;
        if (size != -1) return size;
        
        size = 0;
        if (HasIsTrue) {
          size += pb::CodedOutputStream.ComputeBoolSize(40, IsTrue);
        }
        {
          int dataSize = 0;
          dataSize = 4 * v2F_.Count;
          size += dataSize;
          if (v2F_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize);
          v2FMemoizedSerializedSize = dataSize;
        }
        if (HasSubMes) {
          size += pb::CodedOutputStream.ComputeMessageSize(30, SubMes);
        }
        foreach (global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage element in SubmessersList) {
          size += pb::CodedOutputStream.ComputeMessageSize(31, element);
        }
        if (HasSha) {
          size += pb::CodedOutputStream.ComputeBytesSize(32, Sha);
        }
        {
          int dataSize = 0;
          foreach (pb::ByteString element in ShasList) {
            dataSize += pb::CodedOutputStream.ComputeBytesSizeNoTag(element);
          }
          size += dataSize;
          size += 2 * shas_.Count;
        }
        {
          int dataSize = 0;
          dataSize = 4 * v3F_.Count;
          size += dataSize;
          if (v3F_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize);
          v3FMemoizedSerializedSize = dataSize;
        }
        {
          int dataSize = 0;
          dataSize = 4 * v3Ff_.Count;
          size += dataSize;
          if (v3Ff_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize);
          v3FfMemoizedSerializedSize = dataSize;
        }
        size += UnknownFields.SerializedSize;
        memoizedSerializedSize = size;
        return size;
      }
    }
    
    public static ExternalMessage ParseFrom(pb::ByteString data) {
      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
    }
    public static ExternalMessage ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
    }
    public static ExternalMessage ParseFrom(byte[] data) {
      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
    }
    public static ExternalMessage ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
    }
    public static ExternalMessage ParseFrom(global::System.IO.Stream input) {
      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
    }
    public static ExternalMessage ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
    }
    public static ExternalMessage ParseDelimitedFrom(global::System.IO.Stream input) {
      return CreateBuilder().MergeDelimitedFrom(input).BuildParsed();
    }
    public static ExternalMessage ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
      return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed();
    }
    public static ExternalMessage ParseFrom(pb::CodedInputStream input) {
      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
    }
    public static ExternalMessage ParseFrom(pb::CodedInputStream 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(ExternalMessage prototype) {
      return (Builder) new Builder().MergeFrom(prototype);
    }
    
    public sealed partial class Builder : pb::GeneratedBuilder<ExternalMessage, Builder> {
      protected override Builder ThisBuilder {
        get { return this; }
      }
      public Builder() {}
      
      ExternalMessage result = new ExternalMessage();
      
      protected override ExternalMessage MessageBeingBuilt {
        get { return result; }
      }
      
      public override Builder Clear() {
        result = new ExternalMessage();
        return this;
      }
      
      public override Builder Clone() {
        return new Builder().MergeFrom(result);
      }
      
      public override pbd::MessageDescriptor DescriptorForType {
        get { return global::Sirikata.PB._PBJ_Internal.ExternalMessage.Descriptor; }
      }
      
      public override ExternalMessage DefaultInstanceForType {
        get { return global::Sirikata.PB._PBJ_Internal.ExternalMessage.DefaultInstance; }
      }
      
      public override ExternalMessage BuildPartial() {
        if (result == null) {
          throw new global::System.InvalidOperationException("build() has already been called on this Builder");
        }
        result.v2F_.MakeReadOnly();
        result.submessers_.MakeReadOnly();
        result.shas_.MakeReadOnly();
        result.v3F_.MakeReadOnly();
        result.v3Ff_.MakeReadOnly();
        ExternalMessage returnMe = result;
        result = null;
        return returnMe;
      }
      
      public override Builder MergeFrom(pb::IMessage other) {
        if (other is ExternalMessage) {
          return MergeFrom((ExternalMessage) other);
        } else {
          base.MergeFrom(other);
          return this;
        }
      }
      
      public override Builder MergeFrom(ExternalMessage other) {
        if (other == global::Sirikata.PB._PBJ_Internal.ExternalMessage.DefaultInstance) return this;
        if (other.HasIsTrue) {
          IsTrue = other.IsTrue;
        }
        if (other.v2F_.Count != 0) {
          base.AddRange(other.v2F_, result.v2F_);
        }
        if (other.HasSubMes) {
          MergeSubMes(other.SubMes);
        }
        if (other.submessers_.Count != 0) {
          base.AddRange(other.submessers_, result.submessers_);
        }
        if (other.HasSha) {
          Sha = other.Sha;
        }
        if (other.shas_.Count != 0) {
          base.AddRange(other.shas_, result.shas_);
        }
        if (other.v3F_.Count != 0) {
          base.AddRange(other.v3F_, result.v3F_);
        }
        if (other.v3Ff_.Count != 0) {
          base.AddRange(other.v3Ff_, result.v3Ff_);
        }
        this.MergeUnknownFields(other.UnknownFields);
        return this;
      }
      
      public override Builder MergeFrom(pb::CodedInputStream input) {
        return MergeFrom(input, pb::ExtensionRegistry.Empty);
      }
      
      public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
        pb::UnknownFieldSet.Builder unknownFields = null;
        while (true) {
          uint tag = input.ReadTag();
          switch (tag) {
            case 0: {
              if (unknownFields != null) {
                this.UnknownFields = unknownFields.Build();
              }
              return this;
            }
            default: {
              if (pb::WireFormat.IsEndGroupTag(tag)) {
                if (unknownFields != null) {
                  this.UnknownFields = unknownFields.Build();
                }
                return this;
              }
              if (unknownFields == null) {
                unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
              }
              ParseUnknownField(input, unknownFields, extensionRegistry, tag);
              break;
            }
            case 18: {
              int length = input.ReadInt32();
              int limit = input.PushLimit(length);
              while (!input.ReachedLimit) {
                AddV2F(input.ReadFloat());
              }
              input.PopLimit(limit);
              break;
            }
            case 34: {
              int length = input.ReadInt32();
              int limit = input.PushLimit(length);
              while (!input.ReachedLimit) {
                AddV3F(input.ReadFloat());
              }
              input.PopLimit(limit);
              break;
            }
            case 42: {
              int length = input.ReadInt32();
              int limit = input.PushLimit(length);
              while (!input.ReachedLimit) {
                AddV3Ff(input.ReadFloat());
              }
              input.PopLimit(limit);
              break;
            }
            case 242: {
              global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage.Builder subBuilder = global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage.CreateBuilder();
              if (HasSubMes) {
                subBuilder.MergeFrom(SubMes);
              }
              input.ReadMessage(subBuilder, extensionRegistry);
              SubMes = subBuilder.BuildPartial();
              break;
            }
            case 250: {
              global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage.Builder subBuilder = global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage.CreateBuilder();
              input.ReadMessage(subBuilder, extensionRegistry);
              AddSubmessers(subBuilder.BuildPartial());
              break;
            }
            case 258: {
              Sha = input.ReadBytes();
              break;
            }
            case 266: {
              AddShas(input.ReadBytes());
              break;
            }
            case 320: {
              IsTrue = input.ReadBool();
              break;
            }
          }
        }
      }
      
      
      public bool HasIsTrue {
        get { return result.HasIsTrue; }
      }
      public bool IsTrue {
        get { return result.IsTrue; }
        set { SetIsTrue(value); }
      }
      public Builder SetIsTrue(bool value) {
        result.hasIsTrue = true;
        result.isTrue_ = value;
        return this;
      }
      public Builder ClearIsTrue() {
        result.hasIsTrue = false;
        result.isTrue_ = true;
        return this;
      }
      
      public pbc::IPopsicleList<float> V2FList {
        get { return result.v2F_; }
      }
      public int V2FCount {
        get { return result.V2FCount; }
      }
      public float GetV2F(int index) {
        return result.GetV2F(index);
      }
      public Builder SetV2F(int index, float value) {
        result.v2F_[index] = value;
        return this;
      }
      public Builder AddV2F(float value) {
        result.v2F_.Add(value);
        return this;
      }
      public Builder AddRangeV2F(scg::IEnumerable<float> values) {
        base.AddRange(values, result.v2F_);
        return this;
      }
      public Builder ClearV2F() {
        result.v2F_.Clear();
        return this;
      }
      
      public bool HasSubMes {
       get { return result.HasSubMes; }
      }
      public global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage SubMes {
        get { return result.SubMes; }
        set { SetSubMes(value); }
      }
      public Builder SetSubMes(global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage value) {
        pb::ThrowHelper.ThrowIfNull(value, "value");
        result.hasSubMes = true;
        result.subMes_ = value;
        return this;
      }
      public Builder SetSubMes(global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage.Builder builderForValue) {
        pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue");
        result.hasSubMes = true;
        result.subMes_ = builderForValue.Build();
        return this;
      }
      public Builder MergeSubMes(global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage value) {
        pb::ThrowHelper.ThrowIfNull(value, "value");
        if (result.HasSubMes &&
            result.subMes_ != global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage.DefaultInstance) {
            result.subMes_ = global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage.CreateBuilder(result.subMes_).MergeFrom(value).BuildPartial();
        } else {
          result.subMes_ = value;
        }
        result.hasSubMes = true;
        return this;
      }
      public Builder ClearSubMes() {
        result.hasSubMes = false;
        result.subMes_ = global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage.DefaultInstance;
        return this;
      }
      
      public pbc::IPopsicleList<global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage> SubmessersList {
        get { return result.submessers_; }
      }
      public int SubmessersCount {
        get { return result.SubmessersCount; }
      }
      public global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage GetSubmessers(int index) {
        return result.GetSubmessers(index);
      }
      public Builder SetSubmessers(int index, global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage value) {
        pb::ThrowHelper.ThrowIfNull(value, "value");
        result.submessers_[index] = value;
        return this;
      }
      public Builder SetSubmessers(int index, global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage.Builder builderForValue) {
        pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue");
        result.submessers_[index] = builderForValue.Build();
        return this;
      }
      public Builder AddSubmessers(global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage value) {
        pb::ThrowHelper.ThrowIfNull(value, "value");
        result.submessers_.Add(value);
        return this;
      }
      public Builder AddSubmessers(global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage.Builder builderForValue) {
        pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue");
        result.submessers_.Add(builderForValue.Build());
        return this;
      }
      public Builder AddRangeSubmessers(scg::IEnumerable<global::Sirikata.PB._PBJ_Internal.ExternalMessage.Types.SubMessage> values) {
        base.AddRange(values, result.submessers_);
        return this;
      }
      public Builder ClearSubmessers() {
        result.submessers_.Clear();
        return this;
      }
      
      public bool HasSha {
        get { return result.HasSha; }
      }
      public pb::ByteString Sha {
        get { return result.Sha; }
        set { SetSha(value); }
      }
      public Builder SetSha(pb::ByteString value) {
        pb::ThrowHelper.ThrowIfNull(value, "value");
        result.hasSha = true;
        result.sha_ = value;
        return this;
      }
      public Builder ClearSha() {
        result.hasSha = false;
        result.sha_ = pb::ByteString.Empty;
        return this;
      }
      
      public pbc::IPopsicleList<pb::ByteString> ShasList {
        get { return result.shas_; }
      }
      public int ShasCount {
        get { return result.ShasCount; }
      }
      public pb::ByteString GetShas(int index) {
        return result.GetShas(index);
      }
      public Builder SetShas(int index, pb::ByteString value) {
        pb::ThrowHelper.ThrowIfNull(value, "value");
        result.shas_[index] = value;
        return this;
      }
      public Builder AddShas(pb::ByteString value) {
        pb::ThrowHelper.ThrowIfNull(value, "value");
        result.shas_.Add(value);
        return this;
      }
      public Builder AddRangeShas(scg::IEnumerable<pb::ByteString> values) {
        base.AddRange(values, result.shas_);
        return this;
      }
      public Builder ClearShas() {
        result.shas_.Clear();
        return this;
      }
      
      public pbc::IPopsicleList<float> V3FList {
        get { return result.v3F_; }
      }
      public int V3FCount {
        get { return result.V3FCount; }
      }
      public float GetV3F(int index) {
        return result.GetV3F(index);
      }
      public Builder SetV3F(int index, float value) {
        result.v3F_[index] = value;
        return this;
      }
      public Builder AddV3F(float value) {
        result.v3F_.Add(value);
        return this;
      }
      public Builder AddRangeV3F(scg::IEnumerable<float> values) {
        base.AddRange(values, result.v3F_);
        return this;
      }
      public Builder ClearV3F() {
        result.v3F_.Clear();
        return this;
      }
      
      public pbc::IPopsicleList<float> V3FfList {
        get { return result.v3Ff_; }
      }
      public int V3FfCount {
        get { return result.V3FfCount; }
      }
      public float GetV3Ff(int index) {
        return result.GetV3Ff(index);
      }
      public Builder SetV3Ff(int index, float value) {
        result.v3Ff_[index] = value;
        return this;
      }
      public Builder AddV3Ff(float value) {
        result.v3Ff_.Add(value);
        return this;
      }
      public Builder AddRangeV3Ff(scg::IEnumerable<float> values) {
        base.AddRange(values, result.v3Ff_);
        return this;
      }
      public Builder ClearV3Ff() {
        result.v3Ff_.Clear();
        return this;
      }
    }
    static ExternalMessage() {
      object.ReferenceEquals(global::Sirikata.PB._PBJ_Internal.Test.Descriptor, null);
    }
  }
  
  public sealed partial class TestMessage : pb::ExtendableMessage<TestMessage, TestMessage.Builder> {
    private static readonly TestMessage defaultInstance = new Builder().BuildPartial();
    public static TestMessage DefaultInstance {
      get { return defaultInstance; }
    }
    
    public override TestMessage DefaultInstanceForType {
      get { return defaultInstance; }
    }
    
    protected override TestMessage ThisMessage {
      get { return this; }
    }
    
    public static pbd::MessageDescriptor Descriptor {
      get { return global::Sirikata.PB._PBJ_Internal.Test.internal__static_Sirikata_PB__PBJ_Internal_TestMessage__Descriptor; }
    }
    
    protected override pb::FieldAccess.FieldAccessorTable<TestMessage, TestMessage.Builder> InternalFieldAccessors {
      get { return global::Sirikata.PB._PBJ_Internal.Test.internal__static_Sirikata_PB__PBJ_Internal_TestMessage__FieldAccessorTable; }
    }
    
    #region Nested types
    public static class Types {
      public enum Flagsf32 {
        UNIVERSA = 0,
        WE = 1,
        IMAGE = 2,
        LOCA = 3,
      }
      
      public enum Flagsf64 {
        UNIVERSAL = 0,
        WEB = 1,
        IMAGES = 2,
        LOCAL = 3,
      }
      
      public enum Enum32 {
        UNIVERSAL1 = 0,
        WEB1 = 1,
        IMAGES1 = 2,
        LOCAL1 = 3,
      }
      
      public sealed partial class SubMessage : pb::GeneratedMessage<SubMessage, SubMessage.Builder> {
        private static readonly SubMessage defaultInstance = new Builder().BuildPartial();
        public static SubMessage DefaultInstance {
          get { return defaultInstance; }
        }
        
        public override SubMessage DefaultInstanceForType {
          get { return defaultInstance; }
        }
        
        protected override SubMessage ThisMessage {
          get { return this; }
        }
        
        public static pbd::MessageDescriptor Descriptor {
          get { return global::Sirikata.PB._PBJ_Internal.Test.internal__static_Sirikata_PB__PBJ_Internal_TestMessage_SubMessage__Descriptor; }
        }
        
        protected override pb::FieldAccess.FieldAccessorTable<SubMessage, SubMessage.Builder> InternalFieldAccessors {
          get { return global::Sirikata.PB._PBJ_Internal.Test.internal__static_Sirikata_PB__PBJ_Internal_TestMessage_SubMessage__FieldAccessorTable; }
        }
        
        public const int SubuuidFieldNumber = 1;
        private bool hasSubuuid;
        private pb::ByteString subuuid_ = pb::ByteString.Empty;
        public bool HasSubuuid {
          get { return hasSubuuid; }
        }
        public pb::ByteString Subuuid {
          get { return subuuid_; }
        }
        
        public const int SubvectorFieldNumber = 2;
        private int subvectorMemoizedSerializedSize;
        private pbc::PopsicleList<double> subvector_ = new pbc::PopsicleList<double>();
        public scg::IList<double> SubvectorList {
          get { return pbc::Lists.AsReadOnly(subvector_); }
        }
        public int SubvectorCount {
          get { return subvector_.Count; }
        }
        public double GetSubvector(int index) {
          return subvector_[index];
        }
        
        public const int SubdurationFieldNumber = 3;
        private bool hasSubduration;
        private long subduration_ = 0;
        public bool HasSubduration {
          get { return hasSubduration; }
        }
        public long Subduration {
          get { return subduration_; }
        }
        
        public const int SubnormalFieldNumber = 4;
        private int subnormalMemoizedSerializedSize;
        private pbc::PopsicleList<float> subnormal_ = new pbc::PopsicleList<float>();
        public scg::IList<float> SubnormalList {
          get { return pbc::Lists.AsReadOnly(subnormal_); }
        }
        public int SubnormalCount {
          get { return subnormal_.Count; }
        }
        public float GetSubnormal(int index) {
          return subnormal_[index];
        }
        
        public override bool IsInitialized {
          get {
            return true;
          }
        }
        
        public override void WriteTo(pb::CodedOutputStream output) {
          if (HasSubuuid) {
            output.WriteBytes(1, Subuuid);
          }
          if (subvector_.Count > 0) {
            output.WriteRawVarint32(18);
            output.WriteRawVarint32((uint) subvectorMemoizedSerializedSize);
            foreach (double element in subvector_) {
              output.WriteDoubleNoTag(element);
            }
          }
          if (HasSubduration) {
            output.WriteSFixed64(3, Subduration);
          }
          if (subnormal_.Count > 0) {
            output.WriteRawVarint32(34);
            output.WriteRawVarint32((uint) subnormalMemoizedSerializedSize);
            foreach (float element in subnormal_) {
              output.WriteFloatNoTag(element);
            }
          }
          UnknownFields.WriteTo(output);
        }
        
        private int memoizedSerializedSize = -1;
        public override int SerializedSize {
          get {
            int size = memoizedSerializedSize;
            if (size != -1) return size;
            
            size = 0;
            if (HasSubuuid) {
              size += pb::CodedOutputStream.ComputeBytesSize(1, Subuuid);
            }
            {
              int dataSize = 0;
              dataSize = 8 * subvector_.Count;
              size += dataSize;
              if (subvector_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize);
              subvectorMemoizedSerializedSize = dataSize;
            }
            if (HasSubduration) {
              size += pb::CodedOutputStream.ComputeSFixed64Size(3, Subduration);
            }
            {
              int dataSize = 0;
              dataSize = 4 * subnormal_.Count;
              size += dataSize;
              if (subnormal_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize);
              subnormalMemoizedSerializedSize = dataSize;
            }
            size += UnknownFields.SerializedSize;
            memoizedSerializedSize = size;
            return size;
          }
        }
        
        public static SubMessage ParseFrom(pb::ByteString data) {
          return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
        }
        public static SubMessage ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {
          return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
        }
        public static SubMessage ParseFrom(byte[] data) {
          return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
        }
        public static SubMessage ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {
          return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
        }
        public static SubMessage ParseFrom(global::System.IO.Stream input) {
          return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
        }
        public static SubMessage ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
          return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
        }
        public static SubMessage ParseDelimitedFrom(global::System.IO.Stream input) {
          return CreateBuilder().MergeDelimitedFrom(input).BuildParsed();
        }
        public static SubMessage ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
          return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed();
        }
        public static SubMessage ParseFrom(pb::CodedInputStream input) {
          return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
        }
        public static SubMessage ParseFrom(pb::CodedInputStream 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(SubMessage prototype) {
          return (Builder) new Builder().MergeFrom(prototype);
        }
        
        public sealed partial class Builder : pb::GeneratedBuilder<SubMessage, Builder> {
          protected override Builder ThisBuilder {
            get { return this; }
          }
          public Builder() {}
          
          SubMessage result = new SubMessage();
          
          protected override SubMessage MessageBeingBuilt {
            get { return result; }
          }
          
          public override Builder Clear() {
            result = new SubMessage();
            return this;
          }
          
          public override Builder Clone() {
            return new Builder().MergeFrom(result);
          }
          
          public override pbd::MessageDescriptor DescriptorForType {
            get { return global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage.Descriptor; }
          }
          
          public override SubMessage DefaultInstanceForType {
            get { return global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage.DefaultInstance; }
          }
          
          public override SubMessage BuildPartial() {
            if (result == null) {
              throw new global::System.InvalidOperationException("build() has already been called on this Builder");
            }
            result.subvector_.MakeReadOnly();
            result.subnormal_.MakeReadOnly();
            SubMessage returnMe = result;
            result = null;
            return returnMe;
          }
          
          public override Builder MergeFrom(pb::IMessage other) {
            if (other is SubMessage) {
              return MergeFrom((SubMessage) other);
            } else {
              base.MergeFrom(other);
              return this;
            }
          }
          
          public override Builder MergeFrom(SubMessage other) {
            if (other == global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage.DefaultInstance) return this;
            if (other.HasSubuuid) {
              Subuuid = other.Subuuid;
            }
            if (other.subvector_.Count != 0) {
              base.AddRange(other.subvector_, result.subvector_);
            }
            if (other.HasSubduration) {
              Subduration = other.Subduration;
            }
            if (other.subnormal_.Count != 0) {
              base.AddRange(other.subnormal_, result.subnormal_);
            }
            this.MergeUnknownFields(other.UnknownFields);
            return this;
          }
          
          public override Builder MergeFrom(pb::CodedInputStream input) {
            return MergeFrom(input, pb::ExtensionRegistry.Empty);
          }
          
          public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
            pb::UnknownFieldSet.Builder unknownFields = null;
            while (true) {
              uint tag = input.ReadTag();
              switch (tag) {
                case 0: {
                  if (unknownFields != null) {
                    this.UnknownFields = unknownFields.Build();
                  }
                  return this;
                }
                default: {
                  if (pb::WireFormat.IsEndGroupTag(tag)) {
                    if (unknownFields != null) {
                      this.UnknownFields = unknownFields.Build();
                    }
                    return this;
                  }
                  if (unknownFields == null) {
                    unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
                  }
                  ParseUnknownField(input, unknownFields, extensionRegistry, tag);
                  break;
                }
                case 10: {
                  Subuuid = input.ReadBytes();
                  break;
                }
                case 18: {
                  int length = input.ReadInt32();
                  int limit = input.PushLimit(length);
                  while (!input.ReachedLimit) {
                    AddSubvector(input.ReadDouble());
                  }
                  input.PopLimit(limit);
                  break;
                }
                case 25: {
                  Subduration = input.ReadSFixed64();
                  break;
                }
                case 34: {
                  int length = input.ReadInt32();
                  int limit = input.PushLimit(length);
                  while (!input.ReachedLimit) {
                    AddSubnormal(input.ReadFloat());
                  }
                  input.PopLimit(limit);
                  break;
                }
              }
            }
          }
          
          
          public bool HasSubuuid {
            get { return result.HasSubuuid; }
          }
          public pb::ByteString Subuuid {
            get { return result.Subuuid; }
            set { SetSubuuid(value); }
          }
          public Builder SetSubuuid(pb::ByteString value) {
            pb::ThrowHelper.ThrowIfNull(value, "value");
            result.hasSubuuid = true;
            result.subuuid_ = value;
            return this;
          }
          public Builder ClearSubuuid() {
            result.hasSubuuid = false;
            result.subuuid_ = pb::ByteString.Empty;
            return this;
          }
          
          public pbc::IPopsicleList<double> SubvectorList {
            get { return result.subvector_; }
          }
          public int SubvectorCount {
            get { return result.SubvectorCount; }
          }
          public double GetSubvector(int index) {
            return result.GetSubvector(index);
          }
          public Builder SetSubvector(int index, double value) {
            result.subvector_[index] = value;
            return this;
          }
          public Builder AddSubvector(double value) {
            result.subvector_.Add(value);
            return this;
          }
          public Builder AddRangeSubvector(scg::IEnumerable<double> values) {
            base.AddRange(values, result.subvector_);
            return this;
          }
          public Builder ClearSubvector() {
            result.subvector_.Clear();
            return this;
          }
          
          public bool HasSubduration {
            get { return result.HasSubduration; }
          }
          public long Subduration {
            get { return result.Subduration; }
            set { SetSubduration(value); }
          }
          public Builder SetSubduration(long value) {
            result.hasSubduration = true;
            result.subduration_ = value;
            return this;
          }
          public Builder ClearSubduration() {
            result.hasSubduration = false;
            result.subduration_ = 0;
            return this;
          }
          
          public pbc::IPopsicleList<float> SubnormalList {
            get { return result.subnormal_; }
          }
          public int SubnormalCount {
            get { return result.SubnormalCount; }
          }
          public float GetSubnormal(int index) {
            return result.GetSubnormal(index);
          }
          public Builder SetSubnormal(int index, float value) {
            result.subnormal_[index] = value;
            return this;
          }
          public Builder AddSubnormal(float value) {
            result.subnormal_.Add(value);
            return this;
          }
          public Builder AddRangeSubnormal(scg::IEnumerable<float> values) {
            base.AddRange(values, result.subnormal_);
            return this;
          }
          public Builder ClearSubnormal() {
            result.subnormal_.Clear();
            return this;
          }
        }
        static SubMessage() {
          object.ReferenceEquals(global::Sirikata.PB._PBJ_Internal.Test.Descriptor, null);
        }
      }
      
    }
    #endregion
    
    public const int XxdFieldNumber = 20;
    private bool hasXxd;
    private double xxd_ = 10.3D;
    public bool HasXxd {
      get { return hasXxd; }
    }
    public double Xxd {
      get { return xxd_; }
    }
    
    public const int XxfFieldNumber = 21;
    private bool hasXxf;
    private float xxf_ = 0F;
    public bool HasXxf {
      get { return hasXxf; }
    }
    public float Xxf {
      get { return xxf_; }
    }
    
    public const int Xxu32FieldNumber = 22;
    private bool hasXxu32;
    private uint xxu32_ = 0;
    public bool HasXxu32 {
      get { return hasXxu32; }
    }
    [global::System.CLSCompliant(false)]
    public uint Xxu32 {
      get { return xxu32_; }
    }
    
    public const int XxsFieldNumber = 23;
    private bool hasXxs;
    private string xxs_ = "";
    public bool HasXxs {
      get { return hasXxs; }
    }
    public string Xxs {
      get { return xxs_; }
    }
    
    public const int XxbFieldNumber = 24;
    private bool hasXxb;
    private pb::ByteString xxb_ = pb::ByteString.Empty;
    public bool HasXxb {
      get { return hasXxb; }
    }
    public pb::ByteString Xxb {
      get { return xxb_; }
    }
    
    public const int XxssFieldNumber = 25;
    private pbc::PopsicleList<string> xxss_ = new pbc::PopsicleList<string>();
    public scg::IList<string> XxssList {
      get { return pbc::Lists.AsReadOnly(xxss_); }
    }
    public int XxssCount {
      get { return xxss_.Count; }
    }
    public string GetXxss(int index) {
      return xxss_[index];
    }
    
    public const int XxbbFieldNumber = 26;
    private pbc::PopsicleList<pb::ByteString> xxbb_ = new pbc::PopsicleList<pb::ByteString>();
    public scg::IList<pb::ByteString> XxbbList {
      get { return pbc::Lists.AsReadOnly(xxbb_); }
    }
    public int XxbbCount {
      get { return xxbb_.Count; }
    }
    public pb::ByteString GetXxbb(int index) {
      return xxbb_[index];
    }
    
    public const int XxffFieldNumber = 27;
    private int xxffMemoizedSerializedSize;
    private pbc::PopsicleList<float> xxff_ = new pbc::PopsicleList<float>();
    public scg::IList<float> XxffList {
      get { return pbc::Lists.AsReadOnly(xxff_); }
    }
    public int XxffCount {
      get { return xxff_.Count; }
    }
    public float GetXxff(int index) {
      return xxff_[index];
    }
    
    public const int XxnnFieldNumber = 29;
    private int xxnnMemoizedSerializedSize;
    private pbc::PopsicleList<float> xxnn_ = new pbc::PopsicleList<float>();
    public scg::IList<float> XxnnList {
      get { return pbc::Lists.AsReadOnly(xxnn_); }
    }
    public int XxnnCount {
      get { return xxnn_.Count; }
    }
    public float GetXxnn(int index) {
      return xxnn_[index];
    }
    
    public const int XxfrFieldNumber = 28;
    private bool hasXxfr;
    private float xxfr_ = 0F;
    public bool HasXxfr {
      get { return hasXxfr; }
    }
    public float Xxfr {
      get { return xxfr_; }
    }
    
    public const int NFieldNumber = 1;
    private int nMemoizedSerializedSize;
    private pbc::PopsicleList<float> n_ = new pbc::PopsicleList<float>();
    public scg::IList<float> NList {
      get { return pbc::Lists.AsReadOnly(n_); }
    }
    public int NCount {
      get { return n_.Count; }
    }
    public float GetN(int index) {
      return n_[index];
    }
    
    public const int V2FFieldNumber = 2;
    private int v2FMemoizedSerializedSize;
    private pbc::PopsicleList<float> v2F_ = new pbc::PopsicleList<float>();
    public scg::IList<float> V2FList {
      get { return pbc::Lists.AsReadOnly(v2F_); }
    }
    public int V2FCount {
      get { return v2F_.Count; }
    }
    public float GetV2F(int index) {
      return v2F_[index];
    }
    
    public const int V2DFieldNumber = 3;
    private int v2DMemoizedSerializedSize;
    private pbc::PopsicleList<double> v2D_ = new pbc::PopsicleList<double>();
    public scg::IList<double> V2DList {
      get { return pbc::Lists.AsReadOnly(v2D_); }
    }
    public int V2DCount {
      get { return v2D_.Count; }
    }
    public double GetV2D(int index) {
      return v2D_[index];
    }
    
    public const int V3FFieldNumber = 4;
    private int v3FMemoizedSerializedSize;
    private pbc::PopsicleList<float> v3F_ = new pbc::PopsicleList<float>();
    public scg::IList<float> V3FList {
      get { return pbc::Lists.AsReadOnly(v3F_); }
    }
    public int V3FCount {
      get { return v3F_.Count; }
    }
    public float GetV3F(int index) {
      return v3F_[index];
    }
    
    public const int V3DFieldNumber = 5;
    private int v3DMemoizedSerializedSize;
    private pbc::PopsicleList<double> v3D_ = new pbc::PopsicleList<double>();
    public scg::IList<double> V3DList {
      get { return pbc::Lists.AsReadOnly(v3D_); }
    }
    public int V3DCount {
      get { return v3D_.Count; }
    }
    public double GetV3D(int index) {
      return v3D_[index];
    }
    
    public const int V4FFieldNumber = 6;
    private int v4FMemoizedSerializedSize;
    private pbc::PopsicleList<float> v4F_ = new pbc::PopsicleList<float>();
    public scg::IList<float> V4FList {
      get { return pbc::Lists.AsReadOnly(v4F_); }
    }
    public int V4FCount {
      get { return v4F_.Count; }
    }
    public float GetV4F(int index) {
      return v4F_[index];
    }
    
    public const int V4DFieldNumber = 7;
    private int v4DMemoizedSerializedSize;
    private pbc::PopsicleList<double> v4D_ = new pbc::PopsicleList<double>();
    public scg::IList<double> V4DList {
      get { return pbc::Lists.AsReadOnly(v4D_); }
    }
    public int V4DCount {
      get { return v4D_.Count; }
    }
    public double GetV4D(int index) {
      return v4D_[index];
    }
    
    public const int QFieldNumber = 8;
    private int qMemoizedSerializedSize;
    private pbc::PopsicleList<float> q_ = new pbc::PopsicleList<float>();
    public scg::IList<float> QList {
      get { return pbc::Lists.AsReadOnly(q_); }
    }
    public int QCount {
      get { return q_.Count; }
    }
    public float GetQ(int index) {
      return q_[index];
    }
    
    public const int UFieldNumber = 9;
    private bool hasU;
    private pb::ByteString u_ = pb::ByteString.Empty;
    public bool HasU {
      get { return hasU; }
    }
    public pb::ByteString U {
      get { return u_; }
    }
    
    public const int AFieldNumber = 10;
    private bool hasA;
    private float a_ = 0F;
    public bool HasA {
      get { return hasA; }
    }
    public float A {
      get { return a_; }
    }
    
    public const int TFieldNumber = 11;
    private bool hasT;
    private ulong t_ = 0;
    public bool HasT {
      get { return hasT; }
    }
    [global::System.CLSCompliant(false)]
    public ulong T {
      get { return t_; }
    }
    
    public const int DFieldNumber = 12;
    private bool hasD;
    private long d_ = 0;
    public bool HasD {
      get { return hasD; }
    }
    public long D {
      get { return d_; }
    }
    
    public const int F32FieldNumber = 13;
    private bool hasF32;
    private uint f32_ = 0;
    public bool HasF32 {
      get { return hasF32; }
    }
    [global::System.CLSCompliant(false)]
    public uint F32 {
      get { return f32_; }
    }
    
    public const int F64FieldNumber = 14;
    private bool hasF64;
    private ulong f64_ = 0UL;
    public bool HasF64 {
      get { return hasF64; }
    }
    [global::System.CLSCompliant(false)]
    public ulong F64 {
      get { return f64_; }
    }
    
    public const int BsfFieldNumber = 15;
    private int bsfMemoizedSerializedSize;
    private pbc::PopsicleList<float> bsf_ = new pbc::PopsicleList<float>();
    public scg::IList<float> BsfList {
      get { return pbc::Lists.AsReadOnly(bsf_); }
    }
    public int BsfCount {
      get { return bsf_.Count; }
    }
    public float GetBsf(int index) {
      return bsf_[index];
    }
    
    public const int BsdFieldNumber = 16;
    private int bsdMemoizedSerializedSize;
    private pbc::PopsicleList<double> bsd_ = new pbc::PopsicleList<double>();
    public scg::IList<double> BsdList {
      get { return pbc::Lists.AsReadOnly(bsd_); }
    }
    public int BsdCount {
      get { return bsd_.Count; }
    }
    public double GetBsd(int index) {
      return bsd_[index];
    }
    
    public const int BbfFieldNumber = 17;
    private int bbfMemoizedSerializedSize;
    private pbc::PopsicleList<float> bbf_ = new pbc::PopsicleList<float>();
    public scg::IList<float> BbfList {
      get { return pbc::Lists.AsReadOnly(bbf_); }
    }
    public int BbfCount {
      get { return bbf_.Count; }
    }
    public float GetBbf(int index) {
      return bbf_[index];
    }
    
    public const int BbdFieldNumber = 18;
    private int bbdMemoizedSerializedSize;
    private pbc::PopsicleList<double> bbd_ = new pbc::PopsicleList<double>();
    public scg::IList<double> BbdList {
      get { return pbc::Lists.AsReadOnly(bbd_); }
    }
    public int BbdCount {
      get { return bbd_.Count; }
    }
    public double GetBbd(int index) {
      return bbd_[index];
    }
    
    public const int E32FieldNumber = 19;
    private bool hasE32;
    private global::Sirikata.PB._PBJ_Internal.TestMessage.Types.Enum32 e32_ = global::Sirikata.PB._PBJ_Internal.TestMessage.Types.Enum32.UNIVERSAL1;
    public bool HasE32 {
      get { return hasE32; }
    }
    public global::Sirikata.PB._PBJ_Internal.TestMessage.Types.Enum32 E32 {
      get { return e32_; }
    }
    
    public const int SubmesFieldNumber = 30;
    private bool hasSubmes;
    private global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage submes_ = global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage.DefaultInstance;
    public bool HasSubmes {
      get { return hasSubmes; }
    }
    public global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage Submes {
      get { return submes_; }
    }
    
    public const int SubmessersFieldNumber = 31;
    private pbc::PopsicleList<global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage> submessers_ = new pbc::PopsicleList<global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage>();
    public scg::IList<global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage> SubmessersList {
      get { return submessers_; }
    }
    public int SubmessersCount {
      get { return submessers_.Count; }
    }
    public global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage GetSubmessers(int index) {
      return submessers_[index];
    }
    
    public const int ShaFieldNumber = 32;
    private bool hasSha;
    private pb::ByteString sha_ = pb::ByteString.Empty;
    public bool HasSha {
      get { return hasSha; }
    }
    public pb::ByteString Sha {
      get { return sha_; }
    }
    
    public const int ShasFieldNumber = 33;
    private pbc::PopsicleList<pb::ByteString> shas_ = new pbc::PopsicleList<pb::ByteString>();
    public scg::IList<pb::ByteString> ShasList {
      get { return pbc::Lists.AsReadOnly(shas_); }
    }
    public int ShasCount {
      get { return shas_.Count; }
    }
    public pb::ByteString GetShas(int index) {
      return shas_[index];
    }
    
    public const int ExtmesFieldNumber = 34;
    private bool hasExtmes;
    private global::Sirikata.PB._PBJ_Internal.ExternalMessage extmes_ = global::Sirikata.PB._PBJ_Internal.ExternalMessage.DefaultInstance;
    public bool HasExtmes {
      get { return hasExtmes; }
    }
    public global::Sirikata.PB._PBJ_Internal.ExternalMessage Extmes {
      get { return extmes_; }
    }
    
    public const int ExtmessersFieldNumber = 35;
    private pbc::PopsicleList<global::Sirikata.PB._PBJ_Internal.ExternalMessage> extmessers_ = new pbc::PopsicleList<global::Sirikata.PB._PBJ_Internal.ExternalMessage>();
    public scg::IList<global::Sirikata.PB._PBJ_Internal.ExternalMessage> ExtmessersList {
      get { return extmessers_; }
    }
    public int ExtmessersCount {
      get { return extmessers_.Count; }
    }
    public global::Sirikata.PB._PBJ_Internal.ExternalMessage GetExtmessers(int index) {
      return extmessers_[index];
    }
    
    public const int ExtmesserFieldNumber = 36;
    private bool hasExtmesser;
    private global::Sirikata.PB._PBJ_Internal.ExternalMessage extmesser_ = global::Sirikata.PB._PBJ_Internal.ExternalMessage.DefaultInstance;
    public bool HasExtmesser {
      get { return hasExtmesser; }
    }
    public global::Sirikata.PB._PBJ_Internal.ExternalMessage Extmesser {
      get { return extmesser_; }
    }
    
    public override bool IsInitialized {
      get {
        if (!hasXxfr) return false;
        if (!hasExtmesser) return false;
        if (!ExtensionsAreInitialized) return false;
        return true;
      }
    }
    
    public override void WriteTo(pb::CodedOutputStream output) {
      pb::ExtendableMessage<TestMessage, TestMessage.Builder>.ExtensionWriter extensionWriter = CreateExtensionWriter(this);
      if (n_.Count > 0) {
        output.WriteRawVarint32(10);
        output.WriteRawVarint32((uint) nMemoizedSerializedSize);
        foreach (float element in n_) {
          output.WriteFloatNoTag(element);
        }
      }
      if (v2F_.Count > 0) {
        output.WriteRawVarint32(18);
        output.WriteRawVarint32((uint) v2FMemoizedSerializedSize);
        foreach (float element in v2F_) {
          output.WriteFloatNoTag(element);
        }
      }
      if (v2D_.Count > 0) {
        output.WriteRawVarint32(26);
        output.WriteRawVarint32((uint) v2DMemoizedSerializedSize);
        foreach (double element in v2D_) {
          output.WriteDoubleNoTag(element);
        }
      }
      if (v3F_.Count > 0) {
        output.WriteRawVarint32(34);
        output.WriteRawVarint32((uint) v3FMemoizedSerializedSize);
        foreach (float element in v3F_) {
          output.WriteFloatNoTag(element);
        }
      }
      if (v3D_.Count > 0) {
        output.WriteRawVarint32(42);
        output.WriteRawVarint32((uint) v3DMemoizedSerializedSize);
        foreach (double element in v3D_) {
          output.WriteDoubleNoTag(element);
        }
      }
      if (v4F_.Count > 0) {
        output.WriteRawVarint32(50);
        output.WriteRawVarint32((uint) v4FMemoizedSerializedSize);
        foreach (float element in v4F_) {
          output.WriteFloatNoTag(element);
        }
      }
      if (v4D_.Count > 0) {
        output.WriteRawVarint32(58);
        output.WriteRawVarint32((uint) v4DMemoizedSerializedSize);
        foreach (double element in v4D_) {
          output.WriteDoubleNoTag(element);
        }
      }
      if (q_.Count > 0) {
        output.WriteRawVarint32(66);
        output.WriteRawVarint32((uint) qMemoizedSerializedSize);
        foreach (float element in q_) {
          output.WriteFloatNoTag(element);
        }
      }
      if (HasU) {
        output.WriteBytes(9, U);
      }
      if (HasA) {
        output.WriteFloat(10, A);
      }
      if (HasT) {
        output.WriteFixed64(11, T);
      }
      if (HasD) {
        output.WriteSFixed64(12, D);
      }
      if (HasF32) {
        output.WriteUInt32(13, F32);
      }
      if (HasF64) {
        output.WriteUInt64(14, F64);
      }
      if (bsf_.Count > 0) {
        output.WriteRawVarint32(122);
        output.WriteRawVarint32((uint) bsfMemoizedSerializedSize);
        foreach (float element in bsf_) {
          output.WriteFloatNoTag(element);
        }
      }
      if (bsd_.Count > 0) {
        output.WriteRawVarint32(130);
        output.WriteRawVarint32((uint) bsdMemoizedSerializedSize);
        foreach (double element in bsd_) {
          output.WriteDoubleNoTag(element);
        }
      }
      if (bbf_.Count > 0) {
        output.WriteRawVarint32(138);
        output.WriteRawVarint32((uint) bbfMemoizedSerializedSize);
        foreach (float element in bbf_) {
          output.WriteFloatNoTag(element);
        }
      }
      if (bbd_.Count > 0) {
        output.WriteRawVarint32(146);
        output.WriteRawVarint32((uint) bbdMemoizedSerializedSize);
        foreach (double element in bbd_) {
          output.WriteDoubleNoTag(element);
        }
      }
      if (HasE32) {
        output.WriteEnum(19, (int) E32);
      }
      if (HasXxd) {
        output.WriteDouble(20, Xxd);
      }
      if (HasXxf) {
        output.WriteFloat(21, Xxf);
      }
      if (HasXxu32) {
        output.WriteUInt32(22, Xxu32);
      }
      if (HasXxs) {
        output.WriteString(23, Xxs);
      }
      if (HasXxb) {
        output.WriteBytes(24, Xxb);
      }
      if (xxss_.Count > 0) {
        foreach (string element in xxss_) {
          output.WriteString(25, element);
        }
      }
      if (xxbb_.Count > 0) {
        foreach (pb::ByteString element in xxbb_) {
          output.WriteBytes(26, element);
        }
      }
      if (xxff_.Count > 0) {
        output.WriteRawVarint32(218);
        output.WriteRawVarint32((uint) xxffMemoizedSerializedSize);
        foreach (float element in xxff_) {
          output.WriteFloatNoTag(element);
        }
      }
      if (HasXxfr) {
        output.WriteFloat(28, Xxfr);
      }
      if (xxnn_.Count > 0) {
        output.WriteRawVarint32(234);
        output.WriteRawVarint32((uint) xxnnMemoizedSerializedSize);
        foreach (float element in xxnn_) {
          output.WriteFloatNoTag(element);
        }
      }
      if (HasSubmes) {
        output.WriteMessage(30, Submes);
      }
      foreach (global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage element in SubmessersList) {
        output.WriteMessage(31, element);
      }
      if (HasSha) {
        output.WriteBytes(32, Sha);
      }
      if (shas_.Count > 0) {
        foreach (pb::ByteString element in shas_) {
          output.WriteBytes(33, element);
        }
      }
      if (HasExtmes) {
        output.WriteMessage(34, Extmes);
      }
      foreach (global::Sirikata.PB._PBJ_Internal.ExternalMessage element in ExtmessersList) {
        output.WriteMessage(35, element);
      }
      if (HasExtmesser) {
        output.WriteMessage(36, Extmesser);
      }
      extensionWriter.WriteUntil(200, output);
      UnknownFields.WriteTo(output);
    }
    
    private int memoizedSerializedSize = -1;
    public override int SerializedSize {
      get {
        int size = memoizedSerializedSize;
        if (size != -1) return size;
        
        size = 0;
        if (HasXxd) {
          size += pb::CodedOutputStream.ComputeDoubleSize(20, Xxd);
        }
        if (HasXxf) {
          size += pb::CodedOutputStream.ComputeFloatSize(21, Xxf);
        }
        if (HasXxu32) {
          size += pb::CodedOutputStream.ComputeUInt32Size(22, Xxu32);
        }
        if (HasXxs) {
          size += pb::CodedOutputStream.ComputeStringSize(23, Xxs);
        }
        if (HasXxb) {
          size += pb::CodedOutputStream.ComputeBytesSize(24, Xxb);
        }
        {
          int dataSize = 0;
          foreach (string element in XxssList) {
            dataSize += pb::CodedOutputStream.ComputeStringSizeNoTag(element);
          }
          size += dataSize;
          size += 2 * xxss_.Count;
        }
        {
          int dataSize = 0;
          foreach (pb::ByteString element in XxbbList) {
            dataSize += pb::CodedOutputStream.ComputeBytesSizeNoTag(element);
          }
          size += dataSize;
          size += 2 * xxbb_.Count;
        }
        {
          int dataSize = 0;
          dataSize = 4 * xxff_.Count;
          size += dataSize;
          if (xxff_.Count!=0) size += 2 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize);
          xxffMemoizedSerializedSize = dataSize;
        }
        {
          int dataSize = 0;
          dataSize = 4 * xxnn_.Count;
          size += dataSize;
          if (xxnn_.Count!=0) size += 2 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize);
          xxnnMemoizedSerializedSize = dataSize;
        }
        if (HasXxfr) {
          size += pb::CodedOutputStream.ComputeFloatSize(28, Xxfr);
        }
        {
          int dataSize = 0;
          dataSize = 4 * n_.Count;
          size += dataSize;
          if (n_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize);
          nMemoizedSerializedSize = dataSize;
        }
        {
          int dataSize = 0;
          dataSize = 4 * v2F_.Count;
          size += dataSize;
          if (v2F_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize);
          v2FMemoizedSerializedSize = dataSize;
        }
        {
          int dataSize = 0;
          dataSize = 8 * v2D_.Count;
          size += dataSize;
          if (v2D_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize);
          v2DMemoizedSerializedSize = dataSize;
        }
        {
          int dataSize = 0;
          dataSize = 4 * v3F_.Count;
          size += dataSize;
          if (v3F_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize);
          v3FMemoizedSerializedSize = dataSize;
        }
        {
          int dataSize = 0;
          dataSize = 8 * v3D_.Count;
          size += dataSize;
          if (v3D_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize);
          v3DMemoizedSerializedSize = dataSize;
        }
        {
          int dataSize = 0;
          dataSize = 4 * v4F_.Count;
          size += dataSize;
          if (v4F_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize);
          v4FMemoizedSerializedSize = dataSize;
        }
        {
          int dataSize = 0;
          dataSize = 8 * v4D_.Count;
          size += dataSize;
          if (v4D_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize);
          v4DMemoizedSerializedSize = dataSize;
        }
        {
          int dataSize = 0;
          dataSize = 4 * q_.Count;
          size += dataSize;
          if (q_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize);
          qMemoizedSerializedSize = dataSize;
        }
        if (HasU) {
          size += pb::CodedOutputStream.ComputeBytesSize(9, U);
        }
        if (HasA) {
          size += pb::CodedOutputStream.ComputeFloatSize(10, A);
        }
        if (HasT) {
          size += pb::CodedOutputStream.ComputeFixed64Size(11, T);
        }
        if (HasD) {
          size += pb::CodedOutputStream.ComputeSFixed64Size(12, D);
        }
        if (HasF32) {
          size += pb::CodedOutputStream.ComputeUInt32Size(13, F32);
        }
        if (HasF64) {
          size += pb::CodedOutputStream.ComputeUInt64Size(14, F64);
        }
        {
          int dataSize = 0;
          dataSize = 4 * bsf_.Count;
          size += dataSize;
          if (bsf_.Count!=0) size += 1 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize);
          bsfMemoizedSerializedSize = dataSize;
        }
        {
          int dataSize = 0;
          dataSize = 8 * bsd_.Count;
          size += dataSize;
          if (bsd_.Count!=0) size += 2 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize);
          bsdMemoizedSerializedSize = dataSize;
        }
        {
          int dataSize = 0;
          dataSize = 4 * bbf_.Count;
          size += dataSize;
          if (bbf_.Count!=0) size += 2 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize);
          bbfMemoizedSerializedSize = dataSize;
        }
        {
          int dataSize = 0;
          dataSize = 8 * bbd_.Count;
          size += dataSize;
          if (bbd_.Count!=0) size += 2 + pb::CodedOutputStream.ComputeInt32SizeNoTag(dataSize);
          bbdMemoizedSerializedSize = dataSize;
        }
        if (HasE32) {
          size += pb::CodedOutputStream.ComputeEnumSize(19, (int) E32);
        }
        if (HasSubmes) {
          size += pb::CodedOutputStream.ComputeMessageSize(30, Submes);
        }
        foreach (global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage element in SubmessersList) {
          size += pb::CodedOutputStream.ComputeMessageSize(31, element);
        }
        if (HasSha) {
          size += pb::CodedOutputStream.ComputeBytesSize(32, Sha);
        }
        {
          int dataSize = 0;
          foreach (pb::ByteString element in ShasList) {
            dataSize += pb::CodedOutputStream.ComputeBytesSizeNoTag(element);
          }
          size += dataSize;
          size += 2 * shas_.Count;
        }
        if (HasExtmes) {
          size += pb::CodedOutputStream.ComputeMessageSize(34, Extmes);
        }
        foreach (global::Sirikata.PB._PBJ_Internal.ExternalMessage element in ExtmessersList) {
          size += pb::CodedOutputStream.ComputeMessageSize(35, element);
        }
        if (HasExtmesser) {
          size += pb::CodedOutputStream.ComputeMessageSize(36, Extmesser);
        }
        size += ExtensionsSerializedSize;
        size += UnknownFields.SerializedSize;
        memoizedSerializedSize = size;
        return size;
      }
    }
    
    public static TestMessage ParseFrom(pb::ByteString data) {
      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
    }
    public static TestMessage ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
    }
    public static TestMessage ParseFrom(byte[] data) {
      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
    }
    public static TestMessage ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
    }
    public static TestMessage ParseFrom(global::System.IO.Stream input) {
      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
    }
    public static TestMessage ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
    }
    public static TestMessage ParseDelimitedFrom(global::System.IO.Stream input) {
      return CreateBuilder().MergeDelimitedFrom(input).BuildParsed();
    }
    public static TestMessage ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
      return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed();
    }
    public static TestMessage ParseFrom(pb::CodedInputStream input) {
      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
    }
    public static TestMessage ParseFrom(pb::CodedInputStream 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(TestMessage prototype) {
      return (Builder) new Builder().MergeFrom(prototype);
    }
    
    public sealed partial class Builder : pb::ExtendableBuilder<TestMessage, Builder> {
      protected override Builder ThisBuilder {
        get { return this; }
      }
      public Builder() {}
      
      TestMessage result = new TestMessage();
      
      protected override TestMessage MessageBeingBuilt {
        get { return result; }
      }
      
      public override Builder Clear() {
        result = new TestMessage();
        return this;
      }
      
      public override Builder Clone() {
        return new Builder().MergeFrom(result);
      }
      
      public override pbd::MessageDescriptor DescriptorForType {
        get { return global::Sirikata.PB._PBJ_Internal.TestMessage.Descriptor; }
      }
      
      public override TestMessage DefaultInstanceForType {
        get { return global::Sirikata.PB._PBJ_Internal.TestMessage.DefaultInstance; }
      }
      
      public override TestMessage BuildPartial() {
        if (result == null) {
          throw new global::System.InvalidOperationException("build() has already been called on this Builder");
        }
        result.xxss_.MakeReadOnly();
        result.xxbb_.MakeReadOnly();
        result.xxff_.MakeReadOnly();
        result.xxnn_.MakeReadOnly();
        result.n_.MakeReadOnly();
        result.v2F_.MakeReadOnly();
        result.v2D_.MakeReadOnly();
        result.v3F_.MakeReadOnly();
        result.v3D_.MakeReadOnly();
        result.v4F_.MakeReadOnly();
        result.v4D_.MakeReadOnly();
        result.q_.MakeReadOnly();
        result.bsf_.MakeReadOnly();
        result.bsd_.MakeReadOnly();
        result.bbf_.MakeReadOnly();
        result.bbd_.MakeReadOnly();
        result.submessers_.MakeReadOnly();
        result.shas_.MakeReadOnly();
        result.extmessers_.MakeReadOnly();
        TestMessage returnMe = result;
        result = null;
        return returnMe;
      }
      
      public override Builder MergeFrom(pb::IMessage other) {
        if (other is TestMessage) {
          return MergeFrom((TestMessage) other);
        } else {
          base.MergeFrom(other);
          return this;
        }
      }
      
      public override Builder MergeFrom(TestMessage other) {
        if (other == global::Sirikata.PB._PBJ_Internal.TestMessage.DefaultInstance) return this;
        if (other.HasXxd) {
          Xxd = other.Xxd;
        }
        if (other.HasXxf) {
          Xxf = other.Xxf;
        }
        if (other.HasXxu32) {
          Xxu32 = other.Xxu32;
        }
        if (other.HasXxs) {
          Xxs = other.Xxs;
        }
        if (other.HasXxb) {
          Xxb = other.Xxb;
        }
        if (other.xxss_.Count != 0) {
          base.AddRange(other.xxss_, result.xxss_);
        }
        if (other.xxbb_.Count != 0) {
          base.AddRange(other.xxbb_, result.xxbb_);
        }
        if (other.xxff_.Count != 0) {
          base.AddRange(other.xxff_, result.xxff_);
        }
        if (other.xxnn_.Count != 0) {
          base.AddRange(other.xxnn_, result.xxnn_);
        }
        if (other.HasXxfr) {
          Xxfr = other.Xxfr;
        }
        if (other.n_.Count != 0) {
          base.AddRange(other.n_, result.n_);
        }
        if (other.v2F_.Count != 0) {
          base.AddRange(other.v2F_, result.v2F_);
        }
        if (other.v2D_.Count != 0) {
          base.AddRange(other.v2D_, result.v2D_);
        }
        if (other.v3F_.Count != 0) {
          base.AddRange(other.v3F_, result.v3F_);
        }
        if (other.v3D_.Count != 0) {
          base.AddRange(other.v3D_, result.v3D_);
        }
        if (other.v4F_.Count != 0) {
          base.AddRange(other.v4F_, result.v4F_);
        }
        if (other.v4D_.Count != 0) {
          base.AddRange(other.v4D_, result.v4D_);
        }
        if (other.q_.Count != 0) {
          base.AddRange(other.q_, result.q_);
        }
        if (other.HasU) {
          U = other.U;
        }
        if (other.HasA) {
          A = other.A;
        }
        if (other.HasT) {
          T = other.T;
        }
        if (other.HasD) {
          D = other.D;
        }
        if (other.HasF32) {
          F32 = other.F32;
        }
        if (other.HasF64) {
          F64 = other.F64;
        }
        if (other.bsf_.Count != 0) {
          base.AddRange(other.bsf_, result.bsf_);
        }
        if (other.bsd_.Count != 0) {
          base.AddRange(other.bsd_, result.bsd_);
        }
        if (other.bbf_.Count != 0) {
          base.AddRange(other.bbf_, result.bbf_);
        }
        if (other.bbd_.Count != 0) {
          base.AddRange(other.bbd_, result.bbd_);
        }
        if (other.HasE32) {
          E32 = other.E32;
        }
        if (other.HasSubmes) {
          MergeSubmes(other.Submes);
        }
        if (other.submessers_.Count != 0) {
          base.AddRange(other.submessers_, result.submessers_);
        }
        if (other.HasSha) {
          Sha = other.Sha;
        }
        if (other.shas_.Count != 0) {
          base.AddRange(other.shas_, result.shas_);
        }
        if (other.HasExtmes) {
          MergeExtmes(other.Extmes);
        }
        if (other.extmessers_.Count != 0) {
          base.AddRange(other.extmessers_, result.extmessers_);
        }
        if (other.HasExtmesser) {
          MergeExtmesser(other.Extmesser);
        }
          this.MergeExtensionFields(other);
        this.MergeUnknownFields(other.UnknownFields);
        return this;
      }
      
      public override Builder MergeFrom(pb::CodedInputStream input) {
        return MergeFrom(input, pb::ExtensionRegistry.Empty);
      }
      
      public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
        pb::UnknownFieldSet.Builder unknownFields = null;
        while (true) {
          uint tag = input.ReadTag();
          switch (tag) {
            case 0: {
              if (unknownFields != null) {
                this.UnknownFields = unknownFields.Build();
              }
              return this;
            }
            default: {
              if (pb::WireFormat.IsEndGroupTag(tag)) {
                if (unknownFields != null) {
                  this.UnknownFields = unknownFields.Build();
                }
                return this;
              }
              if (unknownFields == null) {
                unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
              }
              ParseUnknownField(input, unknownFields, extensionRegistry, tag);
              break;
            }
            case 10: {
              int length = input.ReadInt32();
              int limit = input.PushLimit(length);
              while (!input.ReachedLimit) {
                AddN(input.ReadFloat());
              }
              input.PopLimit(limit);
              break;
            }
            case 18: {
              int length = input.ReadInt32();
              int limit = input.PushLimit(length);
              while (!input.ReachedLimit) {
                AddV2F(input.ReadFloat());
              }
              input.PopLimit(limit);
              break;
            }
            case 26: {
              int length = input.ReadInt32();
              int limit = input.PushLimit(length);
              while (!input.ReachedLimit) {
                AddV2D(input.ReadDouble());
              }
              input.PopLimit(limit);
              break;
            }
            case 34: {
              int length = input.ReadInt32();
              int limit = input.PushLimit(length);
              while (!input.ReachedLimit) {
                AddV3F(input.ReadFloat());
              }
              input.PopLimit(limit);
              break;
            }
            case 42: {
              int length = input.ReadInt32();
              int limit = input.PushLimit(length);
              while (!input.ReachedLimit) {
                AddV3D(input.ReadDouble());
              }
              input.PopLimit(limit);
              break;
            }
            case 50: {
              int length = input.ReadInt32();
              int limit = input.PushLimit(length);
              while (!input.ReachedLimit) {
                AddV4F(input.ReadFloat());
              }
              input.PopLimit(limit);
              break;
            }
            case 58: {
              int length = input.ReadInt32();
              int limit = input.PushLimit(length);
              while (!input.ReachedLimit) {
                AddV4D(input.ReadDouble());
              }
              input.PopLimit(limit);
              break;
            }
            case 66: {
              int length = input.ReadInt32();
              int limit = input.PushLimit(length);
              while (!input.ReachedLimit) {
                AddQ(input.ReadFloat());
              }
              input.PopLimit(limit);
              break;
            }
            case 74: {
              U = input.ReadBytes();
              break;
            }
            case 85: {
              A = input.ReadFloat();
              break;
            }
            case 89: {
              T = input.ReadFixed64();
              break;
            }
            case 97: {
              D = input.ReadSFixed64();
              break;
            }
            case 104: {
              F32 = input.ReadUInt32();
              break;
            }
            case 112: {
              F64 = input.ReadUInt64();
              break;
            }
            case 122: {
              int length = input.ReadInt32();
              int limit = input.PushLimit(length);
              while (!input.ReachedLimit) {
                AddBsf(input.ReadFloat());
              }
              input.PopLimit(limit);
              break;
            }
            case 130: {
              int length = input.ReadInt32();
              int limit = input.PushLimit(length);
              while (!input.ReachedLimit) {
                AddBsd(input.ReadDouble());
              }
              input.PopLimit(limit);
              break;
            }
            case 138: {
              int length = input.ReadInt32();
              int limit = input.PushLimit(length);
              while (!input.ReachedLimit) {
                AddBbf(input.ReadFloat());
              }
              input.PopLimit(limit);
              break;
            }
            case 146: {
              int length = input.ReadInt32();
              int limit = input.PushLimit(length);
              while (!input.ReachedLimit) {
                AddBbd(input.ReadDouble());
              }
              input.PopLimit(limit);
              break;
            }
            case 152: {
              int rawValue = input.ReadEnum();
              if (!global::System.Enum.IsDefined(typeof(global::Sirikata.PB._PBJ_Internal.TestMessage.Types.Enum32), rawValue)) {
                if (unknownFields == null) {
                  unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
                }
                unknownFields.MergeVarintField(19, (ulong) rawValue);
              } else {
                E32 = (global::Sirikata.PB._PBJ_Internal.TestMessage.Types.Enum32) rawValue;
              }
              break;
            }
            case 161: {
              Xxd = input.ReadDouble();
              break;
            }
            case 173: {
              Xxf = input.ReadFloat();
              break;
            }
            case 176: {
              Xxu32 = input.ReadUInt32();
              break;
            }
            case 186: {
              Xxs = input.ReadString();
              break;
            }
            case 194: {
              Xxb = input.ReadBytes();
              break;
            }
            case 202: {
              AddXxss(input.ReadString());
              break;
            }
            case 210: {
              AddXxbb(input.ReadBytes());
              break;
            }
            case 218: {
              int length = input.ReadInt32();
              int limit = input.PushLimit(length);
              while (!input.ReachedLimit) {
                AddXxff(input.ReadFloat());
              }
              input.PopLimit(limit);
              break;
            }
            case 229: {
              Xxfr = input.ReadFloat();
              break;
            }
            case 234: {
              int length = input.ReadInt32();
              int limit = input.PushLimit(length);
              while (!input.ReachedLimit) {
                AddXxnn(input.ReadFloat());
              }
              input.PopLimit(limit);
              break;
            }
            case 242: {
              global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage.Builder subBuilder = global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage.CreateBuilder();
              if (HasSubmes) {
                subBuilder.MergeFrom(Submes);
              }
              input.ReadMessage(subBuilder, extensionRegistry);
              Submes = subBuilder.BuildPartial();
              break;
            }
            case 250: {
              global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage.Builder subBuilder = global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage.CreateBuilder();
              input.ReadMessage(subBuilder, extensionRegistry);
              AddSubmessers(subBuilder.BuildPartial());
              break;
            }
            case 258: {
              Sha = input.ReadBytes();
              break;
            }
            case 266: {
              AddShas(input.ReadBytes());
              break;
            }
            case 274: {
              global::Sirikata.PB._PBJ_Internal.ExternalMessage.Builder subBuilder = global::Sirikata.PB._PBJ_Internal.ExternalMessage.CreateBuilder();
              if (HasExtmes) {
                subBuilder.MergeFrom(Extmes);
              }
              input.ReadMessage(subBuilder, extensionRegistry);
              Extmes = subBuilder.BuildPartial();
              break;
            }
            case 282: {
              global::Sirikata.PB._PBJ_Internal.ExternalMessage.Builder subBuilder = global::Sirikata.PB._PBJ_Internal.ExternalMessage.CreateBuilder();
              input.ReadMessage(subBuilder, extensionRegistry);
              AddExtmessers(subBuilder.BuildPartial());
              break;
            }
            case 290: {
              global::Sirikata.PB._PBJ_Internal.ExternalMessage.Builder subBuilder = global::Sirikata.PB._PBJ_Internal.ExternalMessage.CreateBuilder();
              if (HasExtmesser) {
                subBuilder.MergeFrom(Extmesser);
              }
              input.ReadMessage(subBuilder, extensionRegistry);
              Extmesser = subBuilder.BuildPartial();
              break;
            }
          }
        }
      }
      
      
      public bool HasXxd {
        get { return result.HasXxd; }
      }
      public double Xxd {
        get { return result.Xxd; }
        set { SetXxd(value); }
      }
      public Builder SetXxd(double value) {
        result.hasXxd = true;
        result.xxd_ = value;
        return this;
      }
      public Builder ClearXxd() {
        result.hasXxd = false;
        result.xxd_ = 10.3D;
        return this;
      }
      
      public bool HasXxf {
        get { return result.HasXxf; }
      }
      public float Xxf {
        get { return result.Xxf; }
        set { SetXxf(value); }
      }
      public Builder SetXxf(float value) {
        result.hasXxf = true;
        result.xxf_ = value;
        return this;
      }
      public Builder ClearXxf() {
        result.hasXxf = false;
        result.xxf_ = 0F;
        return this;
      }
      
      public bool HasXxu32 {
        get { return result.HasXxu32; }
      }
      [global::System.CLSCompliant(false)]
      public uint Xxu32 {
        get { return result.Xxu32; }
        set { SetXxu32(value); }
      }
      [global::System.CLSCompliant(false)]
      public Builder SetXxu32(uint value) {
        result.hasXxu32 = true;
        result.xxu32_ = value;
        return this;
      }
      public Builder ClearXxu32() {
        result.hasXxu32 = false;
        result.xxu32_ = 0;
        return this;
      }
      
      public bool HasXxs {
        get { return result.HasXxs; }
      }
      public string Xxs {
        get { return result.Xxs; }
        set { SetXxs(value); }
      }
      public Builder SetXxs(string value) {
        pb::ThrowHelper.ThrowIfNull(value, "value");
        result.hasXxs = true;
        result.xxs_ = value;
        return this;
      }
      public Builder ClearXxs() {
        result.hasXxs = false;
        result.xxs_ = "";
        return this;
      }
      
      public bool HasXxb {
        get { return result.HasXxb; }
      }
      public pb::ByteString Xxb {
        get { return result.Xxb; }
        set { SetXxb(value); }
      }
      public Builder SetXxb(pb::ByteString value) {
        pb::ThrowHelper.ThrowIfNull(value, "value");
        result.hasXxb = true;
        result.xxb_ = value;
        return this;
      }
      public Builder ClearXxb() {
        result.hasXxb = false;
        result.xxb_ = pb::ByteString.Empty;
        return this;
      }
      
      public pbc::IPopsicleList<string> XxssList {
        get { return result.xxss_; }
      }
      public int XxssCount {
        get { return result.XxssCount; }
      }
      public string GetXxss(int index) {
        return result.GetXxss(index);
      }
      public Builder SetXxss(int index, string value) {
        pb::ThrowHelper.ThrowIfNull(value, "value");
        result.xxss_[index] = value;
        return this;
      }
      public Builder AddXxss(string value) {
        pb::ThrowHelper.ThrowIfNull(value, "value");
        result.xxss_.Add(value);
        return this;
      }
      public Builder AddRangeXxss(scg::IEnumerable<string> values) {
        base.AddRange(values, result.xxss_);
        return this;
      }
      public Builder ClearXxss() {
        result.xxss_.Clear();
        return this;
      }
      
      public pbc::IPopsicleList<pb::ByteString> XxbbList {
        get { return result.xxbb_; }
      }
      public int XxbbCount {
        get { return result.XxbbCount; }
      }
      public pb::ByteString GetXxbb(int index) {
        return result.GetXxbb(index);
      }
      public Builder SetXxbb(int index, pb::ByteString value) {
        pb::ThrowHelper.ThrowIfNull(value, "value");
        result.xxbb_[index] = value;
        return this;
      }
      public Builder AddXxbb(pb::ByteString value) {
        pb::ThrowHelper.ThrowIfNull(value, "value");
        result.xxbb_.Add(value);
        return this;
      }
      public Builder AddRangeXxbb(scg::IEnumerable<pb::ByteString> values) {
        base.AddRange(values, result.xxbb_);
        return this;
      }
      public Builder ClearXxbb() {
        result.xxbb_.Clear();
        return this;
      }
      
      public pbc::IPopsicleList<float> XxffList {
        get { return result.xxff_; }
      }
      public int XxffCount {
        get { return result.XxffCount; }
      }
      public float GetXxff(int index) {
        return result.GetXxff(index);
      }
      public Builder SetXxff(int index, float value) {
        result.xxff_[index] = value;
        return this;
      }
      public Builder AddXxff(float value) {
        result.xxff_.Add(value);
        return this;
      }
      public Builder AddRangeXxff(scg::IEnumerable<float> values) {
        base.AddRange(values, result.xxff_);
        return this;
      }
      public Builder ClearXxff() {
        result.xxff_.Clear();
        return this;
      }
      
      public pbc::IPopsicleList<float> XxnnList {
        get { return result.xxnn_; }
      }
      public int XxnnCount {
        get { return result.XxnnCount; }
      }
      public float GetXxnn(int index) {
        return result.GetXxnn(index);
      }
      public Builder SetXxnn(int index, float value) {
        result.xxnn_[index] = value;
        return this;
      }
      public Builder AddXxnn(float value) {
        result.xxnn_.Add(value);
        return this;
      }
      public Builder AddRangeXxnn(scg::IEnumerable<float> values) {
        base.AddRange(values, result.xxnn_);
        return this;
      }
      public Builder ClearXxnn() {
        result.xxnn_.Clear();
        return this;
      }
      
      public bool HasXxfr {
        get { return result.HasXxfr; }
      }
      public float Xxfr {
        get { return result.Xxfr; }
        set { SetXxfr(value); }
      }
      public Builder SetXxfr(float value) {
        result.hasXxfr = true;
        result.xxfr_ = value;
        return this;
      }
      public Builder ClearXxfr() {
        result.hasXxfr = false;
        result.xxfr_ = 0F;
        return this;
      }
      
      public pbc::IPopsicleList<float> NList {
        get { return result.n_; }
      }
      public int NCount {
        get { return result.NCount; }
      }
      public float GetN(int index) {
        return result.GetN(index);
      }
      public Builder SetN(int index, float value) {
        result.n_[index] = value;
        return this;
      }
      public Builder AddN(float value) {
        result.n_.Add(value);
        return this;
      }
      public Builder AddRangeN(scg::IEnumerable<float> values) {
        base.AddRange(values, result.n_);
        return this;
      }
      public Builder ClearN() {
        result.n_.Clear();
        return this;
      }
      
      public pbc::IPopsicleList<float> V2FList {
        get { return result.v2F_; }
      }
      public int V2FCount {
        get { return result.V2FCount; }
      }
      public float GetV2F(int index) {
        return result.GetV2F(index);
      }
      public Builder SetV2F(int index, float value) {
        result.v2F_[index] = value;
        return this;
      }
      public Builder AddV2F(float value) {
        result.v2F_.Add(value);
        return this;
      }
      public Builder AddRangeV2F(scg::IEnumerable<float> values) {
        base.AddRange(values, result.v2F_);
        return this;
      }
      public Builder ClearV2F() {
        result.v2F_.Clear();
        return this;
      }
      
      public pbc::IPopsicleList<double> V2DList {
        get { return result.v2D_; }
      }
      public int V2DCount {
        get { return result.V2DCount; }
      }
      public double GetV2D(int index) {
        return result.GetV2D(index);
      }
      public Builder SetV2D(int index, double value) {
        result.v2D_[index] = value;
        return this;
      }
      public Builder AddV2D(double value) {
        result.v2D_.Add(value);
        return this;
      }
      public Builder AddRangeV2D(scg::IEnumerable<double> values) {
        base.AddRange(values, result.v2D_);
        return this;
      }
      public Builder ClearV2D() {
        result.v2D_.Clear();
        return this;
      }
      
      public pbc::IPopsicleList<float> V3FList {
        get { return result.v3F_; }
      }
      public int V3FCount {
        get { return result.V3FCount; }
      }
      public float GetV3F(int index) {
        return result.GetV3F(index);
      }
      public Builder SetV3F(int index, float value) {
        result.v3F_[index] = value;
        return this;
      }
      public Builder AddV3F(float value) {
        result.v3F_.Add(value);
        return this;
      }
      public Builder AddRangeV3F(scg::IEnumerable<float> values) {
        base.AddRange(values, result.v3F_);
        return this;
      }
      public Builder ClearV3F() {
        result.v3F_.Clear();
        return this;
      }
      
      public pbc::IPopsicleList<double> V3DList {
        get { return result.v3D_; }
      }
      public int V3DCount {
        get { return result.V3DCount; }
      }
      public double GetV3D(int index) {
        return result.GetV3D(index);
      }
      public Builder SetV3D(int index, double value) {
        result.v3D_[index] = value;
        return this;
      }
      public Builder AddV3D(double value) {
        result.v3D_.Add(value);
        return this;
      }
      public Builder AddRangeV3D(scg::IEnumerable<double> values) {
        base.AddRange(values, result.v3D_);
        return this;
      }
      public Builder ClearV3D() {
        result.v3D_.Clear();
        return this;
      }
      
      public pbc::IPopsicleList<float> V4FList {
        get { return result.v4F_; }
      }
      public int V4FCount {
        get { return result.V4FCount; }
      }
      public float GetV4F(int index) {
        return result.GetV4F(index);
      }
      public Builder SetV4F(int index, float value) {
        result.v4F_[index] = value;
        return this;
      }
      public Builder AddV4F(float value) {
        result.v4F_.Add(value);
        return this;
      }
      public Builder AddRangeV4F(scg::IEnumerable<float> values) {
        base.AddRange(values, result.v4F_);
        return this;
      }
      public Builder ClearV4F() {
        result.v4F_.Clear();
        return this;
      }
      
      public pbc::IPopsicleList<double> V4DList {
        get { return result.v4D_; }
      }
      public int V4DCount {
        get { return result.V4DCount; }
      }
      public double GetV4D(int index) {
        return result.GetV4D(index);
      }
      public Builder SetV4D(int index, double value) {
        result.v4D_[index] = value;
        return this;
      }
      public Builder AddV4D(double value) {
        result.v4D_.Add(value);
        return this;
      }
      public Builder AddRangeV4D(scg::IEnumerable<double> values) {
        base.AddRange(values, result.v4D_);
        return this;
      }
      public Builder ClearV4D() {
        result.v4D_.Clear();
        return this;
      }
      
      public pbc::IPopsicleList<float> QList {
        get { return result.q_; }
      }
      public int QCount {
        get { return result.QCount; }
      }
      public float GetQ(int index) {
        return result.GetQ(index);
      }
      public Builder SetQ(int index, float value) {
        result.q_[index] = value;
        return this;
      }
      public Builder AddQ(float value) {
        result.q_.Add(value);
        return this;
      }
      public Builder AddRangeQ(scg::IEnumerable<float> values) {
        base.AddRange(values, result.q_);
        return this;
      }
      public Builder ClearQ() {
        result.q_.Clear();
        return this;
      }
      
      public bool HasU {
        get { return result.HasU; }
      }
      public pb::ByteString U {
        get { return result.U; }
        set { SetU(value); }
      }
      public Builder SetU(pb::ByteString value) {
        pb::ThrowHelper.ThrowIfNull(value, "value");
        result.hasU = true;
        result.u_ = value;
        return this;
      }
      public Builder ClearU() {
        result.hasU = false;
        result.u_ = pb::ByteString.Empty;
        return this;
      }
      
      public bool HasA {
        get { return result.HasA; }
      }
      public float A {
        get { return result.A; }
        set { SetA(value); }
      }
      public Builder SetA(float value) {
        result.hasA = true;
        result.a_ = value;
        return this;
      }
      public Builder ClearA() {
        result.hasA = false;
        result.a_ = 0F;
        return this;
      }
      
      public bool HasT {
        get { return result.HasT; }
      }
      [global::System.CLSCompliant(false)]
      public ulong T {
        get { return result.T; }
        set { SetT(value); }
      }
      [global::System.CLSCompliant(false)]
      public Builder SetT(ulong value) {
        result.hasT = true;
        result.t_ = value;
        return this;
      }
      public Builder ClearT() {
        result.hasT = false;
        result.t_ = 0;
        return this;
      }
      
      public bool HasD {
        get { return result.HasD; }
      }
      public long D {
        get { return result.D; }
        set { SetD(value); }
      }
      public Builder SetD(long value) {
        result.hasD = true;
        result.d_ = value;
        return this;
      }
      public Builder ClearD() {
        result.hasD = false;
        result.d_ = 0;
        return this;
      }
      
      public bool HasF32 {
        get { return result.HasF32; }
      }
      [global::System.CLSCompliant(false)]
      public uint F32 {
        get { return result.F32; }
        set { SetF32(value); }
      }
      [global::System.CLSCompliant(false)]
      public Builder SetF32(uint value) {
        result.hasF32 = true;
        result.f32_ = value;
        return this;
      }
      public Builder ClearF32() {
        result.hasF32 = false;
        result.f32_ = 0;
        return this;
      }
      
      public bool HasF64 {
        get { return result.HasF64; }
      }
      [global::System.CLSCompliant(false)]
      public ulong F64 {
        get { return result.F64; }
        set { SetF64(value); }
      }
      [global::System.CLSCompliant(false)]
      public Builder SetF64(ulong value) {
        result.hasF64 = true;
        result.f64_ = value;
        return this;
      }
      public Builder ClearF64() {
        result.hasF64 = false;
        result.f64_ = 0UL;
        return this;
      }
      
      public pbc::IPopsicleList<float> BsfList {
        get { return result.bsf_; }
      }
      public int BsfCount {
        get { return result.BsfCount; }
      }
      public float GetBsf(int index) {
        return result.GetBsf(index);
      }
      public Builder SetBsf(int index, float value) {
        result.bsf_[index] = value;
        return this;
      }
      public Builder AddBsf(float value) {
        result.bsf_.Add(value);
        return this;
      }
      public Builder AddRangeBsf(scg::IEnumerable<float> values) {
        base.AddRange(values, result.bsf_);
        return this;
      }
      public Builder ClearBsf() {
        result.bsf_.Clear();
        return this;
      }
      
      public pbc::IPopsicleList<double> BsdList {
        get { return result.bsd_; }
      }
      public int BsdCount {
        get { return result.BsdCount; }
      }
      public double GetBsd(int index) {
        return result.GetBsd(index);
      }
      public Builder SetBsd(int index, double value) {
        result.bsd_[index] = value;
        return this;
      }
      public Builder AddBsd(double value) {
        result.bsd_.Add(value);
        return this;
      }
      public Builder AddRangeBsd(scg::IEnumerable<double> values) {
        base.AddRange(values, result.bsd_);
        return this;
      }
      public Builder ClearBsd() {
        result.bsd_.Clear();
        return this;
      }
      
      public pbc::IPopsicleList<float> BbfList {
        get { return result.bbf_; }
      }
      public int BbfCount {
        get { return result.BbfCount; }
      }
      public float GetBbf(int index) {
        return result.GetBbf(index);
      }
      public Builder SetBbf(int index, float value) {
        result.bbf_[index] = value;
        return this;
      }
      public Builder AddBbf(float value) {
        result.bbf_.Add(value);
        return this;
      }
      public Builder AddRangeBbf(scg::IEnumerable<float> values) {
        base.AddRange(values, result.bbf_);
        return this;
      }
      public Builder ClearBbf() {
        result.bbf_.Clear();
        return this;
      }
      
      public pbc::IPopsicleList<double> BbdList {
        get { return result.bbd_; }
      }
      public int BbdCount {
        get { return result.BbdCount; }
      }
      public double GetBbd(int index) {
        return result.GetBbd(index);
      }
      public Builder SetBbd(int index, double value) {
        result.bbd_[index] = value;
        return this;
      }
      public Builder AddBbd(double value) {
        result.bbd_.Add(value);
        return this;
      }
      public Builder AddRangeBbd(scg::IEnumerable<double> values) {
        base.AddRange(values, result.bbd_);
        return this;
      }
      public Builder ClearBbd() {
        result.bbd_.Clear();
        return this;
      }
      
      public bool HasE32 {
       get { return result.HasE32; }
      }
      public global::Sirikata.PB._PBJ_Internal.TestMessage.Types.Enum32 E32 {
        get { return result.E32; }
        set { SetE32(value); }
      }
      public Builder SetE32(global::Sirikata.PB._PBJ_Internal.TestMessage.Types.Enum32 value) {
        result.hasE32 = true;
        result.e32_ = value;
        return this;
      }
      public Builder ClearE32() {
        result.hasE32 = false;
        result.e32_ = global::Sirikata.PB._PBJ_Internal.TestMessage.Types.Enum32.UNIVERSAL1;
        return this;
      }
      
      public bool HasSubmes {
       get { return result.HasSubmes; }
      }
      public global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage Submes {
        get { return result.Submes; }
        set { SetSubmes(value); }
      }
      public Builder SetSubmes(global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage value) {
        pb::ThrowHelper.ThrowIfNull(value, "value");
        result.hasSubmes = true;
        result.submes_ = value;
        return this;
      }
      public Builder SetSubmes(global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage.Builder builderForValue) {
        pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue");
        result.hasSubmes = true;
        result.submes_ = builderForValue.Build();
        return this;
      }
      public Builder MergeSubmes(global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage value) {
        pb::ThrowHelper.ThrowIfNull(value, "value");
        if (result.HasSubmes &&
            result.submes_ != global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage.DefaultInstance) {
            result.submes_ = global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage.CreateBuilder(result.submes_).MergeFrom(value).BuildPartial();
        } else {
          result.submes_ = value;
        }
        result.hasSubmes = true;
        return this;
      }
      public Builder ClearSubmes() {
        result.hasSubmes = false;
        result.submes_ = global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage.DefaultInstance;
        return this;
      }
      
      public pbc::IPopsicleList<global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage> SubmessersList {
        get { return result.submessers_; }
      }
      public int SubmessersCount {
        get { return result.SubmessersCount; }
      }
      public global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage GetSubmessers(int index) {
        return result.GetSubmessers(index);
      }
      public Builder SetSubmessers(int index, global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage value) {
        pb::ThrowHelper.ThrowIfNull(value, "value");
        result.submessers_[index] = value;
        return this;
      }
      public Builder SetSubmessers(int index, global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage.Builder builderForValue) {
        pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue");
        result.submessers_[index] = builderForValue.Build();
        return this;
      }
      public Builder AddSubmessers(global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage value) {
        pb::ThrowHelper.ThrowIfNull(value, "value");
        result.submessers_.Add(value);
        return this;
      }
      public Builder AddSubmessers(global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage.Builder builderForValue) {
        pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue");
        result.submessers_.Add(builderForValue.Build());
        return this;
      }
      public Builder AddRangeSubmessers(scg::IEnumerable<global::Sirikata.PB._PBJ_Internal.TestMessage.Types.SubMessage> values) {
        base.AddRange(values, result.submessers_);
        return this;
      }
      public Builder ClearSubmessers() {
        result.submessers_.Clear();
        return this;
      }
      
      public bool HasSha {
        get { return result.HasSha; }
      }
      public pb::ByteString Sha {
        get { return result.Sha; }
        set { SetSha(value); }
      }
      public Builder SetSha(pb::ByteString value) {
        pb::ThrowHelper.ThrowIfNull(value, "value");
        result.hasSha = true;
        result.sha_ = value;
        return this;
      }
      public Builder ClearSha() {
        result.hasSha = false;
        result.sha_ = pb::ByteString.Empty;
        return this;
      }
      
      public pbc::IPopsicleList<pb::ByteString> ShasList {
        get { return result.shas_; }
      }
      public int ShasCount {
        get { return result.ShasCount; }
      }
      public pb::ByteString GetShas(int index) {
        return result.GetShas(index);
      }
      public Builder SetShas(int index, pb::ByteString value) {
        pb::ThrowHelper.ThrowIfNull(value, "value");
        result.shas_[index] = value;
        return this;
      }
      public Builder AddShas(pb::ByteString value) {
        pb::ThrowHelper.ThrowIfNull(value, "value");
        result.shas_.Add(value);
        return this;
      }
      public Builder AddRangeShas(scg::IEnumerable<pb::ByteString> values) {
        base.AddRange(values, result.shas_);
        return this;
      }
      public Builder ClearShas() {
        result.shas_.Clear();
        return this;
      }
      
      public bool HasExtmes {
       get { return result.HasExtmes; }
      }
      public global::Sirikata.PB._PBJ_Internal.ExternalMessage Extmes {
        get { return result.Extmes; }
        set { SetExtmes(value); }
      }
      public Builder SetExtmes(global::Sirikata.PB._PBJ_Internal.ExternalMessage value) {
        pb::ThrowHelper.ThrowIfNull(value, "value");
        result.hasExtmes = true;
        result.extmes_ = value;
        return this;
      }
      public Builder SetExtmes(global::Sirikata.PB._PBJ_Internal.ExternalMessage.Builder builderForValue) {
        pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue");
        result.hasExtmes = true;
        result.extmes_ = builderForValue.Build();
        return this;
      }
      public Builder MergeExtmes(global::Sirikata.PB._PBJ_Internal.ExternalMessage value) {
        pb::ThrowHelper.ThrowIfNull(value, "value");
        if (result.HasExtmes &&
            result.extmes_ != global::Sirikata.PB._PBJ_Internal.ExternalMessage.DefaultInstance) {
            result.extmes_ = global::Sirikata.PB._PBJ_Internal.ExternalMessage.CreateBuilder(result.extmes_).MergeFrom(value).BuildPartial();
        } else {
          result.extmes_ = value;
        }
        result.hasExtmes = true;
        return this;
      }
      public Builder ClearExtmes() {
        result.hasExtmes = false;
        result.extmes_ = global::Sirikata.PB._PBJ_Internal.ExternalMessage.DefaultInstance;
        return this;
      }
      
      public pbc::IPopsicleList<global::Sirikata.PB._PBJ_Internal.ExternalMessage> ExtmessersList {
        get { return result.extmessers_; }
      }
      public int ExtmessersCount {
        get { return result.ExtmessersCount; }
      }
      public global::Sirikata.PB._PBJ_Internal.ExternalMessage GetExtmessers(int index) {
        return result.GetExtmessers(index);
      }
      public Builder SetExtmessers(int index, global::Sirikata.PB._PBJ_Internal.ExternalMessage value) {
        pb::ThrowHelper.ThrowIfNull(value, "value");
        result.extmessers_[index] = value;
        return this;
      }
      public Builder SetExtmessers(int index, global::Sirikata.PB._PBJ_Internal.ExternalMessage.Builder builderForValue) {
        pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue");
        result.extmessers_[index] = builderForValue.Build();
        return this;
      }
      public Builder AddExtmessers(global::Sirikata.PB._PBJ_Internal.ExternalMessage value) {
        pb::ThrowHelper.ThrowIfNull(value, "value");
        result.extmessers_.Add(value);
        return this;
      }
      public Builder AddExtmessers(global::Sirikata.PB._PBJ_Internal.ExternalMessage.Builder builderForValue) {
        pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue");
        result.extmessers_.Add(builderForValue.Build());
        return this;
      }
      public Builder AddRangeExtmessers(scg::IEnumerable<global::Sirikata.PB._PBJ_Internal.ExternalMessage> values) {
        base.AddRange(values, result.extmessers_);
        return this;
      }
      public Builder ClearExtmessers() {
        result.extmessers_.Clear();
        return this;
      }
      
      public bool HasExtmesser {
       get { return result.HasExtmesser; }
      }
      public global::Sirikata.PB._PBJ_Internal.ExternalMessage Extmesser {
        get { return result.Extmesser; }
        set { SetExtmesser(value); }
      }
      public Builder SetExtmesser(global::Sirikata.PB._PBJ_Internal.ExternalMessage value) {
        pb::ThrowHelper.ThrowIfNull(value, "value");
        result.hasExtmesser = true;
        result.extmesser_ = value;
        return this;
      }
      public Builder SetExtmesser(global::Sirikata.PB._PBJ_Internal.ExternalMessage.Builder builderForValue) {
        pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue");
        result.hasExtmesser = true;
        result.extmesser_ = builderForValue.Build();
        return this;
      }
      public Builder MergeExtmesser(global::Sirikata.PB._PBJ_Internal.ExternalMessage value) {
        pb::ThrowHelper.ThrowIfNull(value, "value");
        if (result.HasExtmesser &&
            result.extmesser_ != global::Sirikata.PB._PBJ_Internal.ExternalMessage.DefaultInstance) {
            result.extmesser_ = global::Sirikata.PB._PBJ_Internal.ExternalMessage.CreateBuilder(result.extmesser_).MergeFrom(value).BuildPartial();
        } else {
          result.extmesser_ = value;
        }
        result.hasExtmesser = true;
        return this;
      }
      public Builder ClearExtmesser() {
        result.hasExtmesser = false;
        result.extmesser_ = global::Sirikata.PB._PBJ_Internal.ExternalMessage.DefaultInstance;
        return this;
      }
    }
    static TestMessage() {
      object.ReferenceEquals(global::Sirikata.PB._PBJ_Internal.Test.Descriptor, null);
    }
  }
  
  #endregion
  
}
