* Implements Sirikata ClientStack Module

* Just a stub (imports all the sirikata protocol, and that's about it.)

1 files changed, 3773 insertions, 0 deletions

diff --git a/OpenSim/Client/Sirikata/Protocol/Test.cs b/OpenSim/Client/Sirikata/Protocol/Test.cs
new file mode 100644
index 0000000..0e1372a
--- /dev/null
+++ b/OpenSim/Client/Sirikata/Protocol/Test.cs
@@ -0,0 +1,3773 @@
+// 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
+  
+}