Adding the types that were removed from unittest.proto and unittest_lite.proto

build/build.csproj

@@ -37,6 +37,7 @@
     <WorkingDirectories Include="$(BuildOutputDirectory)" />
 
     <Protos Include="$(ProtosDirectory)\extest\unittest_issues.proto" />
+    <Protos Include="$(ProtosDirectory)\extest\unittest_extras.proto" />
     <Protos Include="$(ProtosDirectory)\extest\unittest_extras_full.proto" />
     <Protos Include="$(ProtosDirectory)\extest\unittest_extras_lite.proto" />
     <Protos Include="$(ProtosDirectory)\extest\unittest_extras_xmltest.proto" />
@@ -72,6 +73,9 @@
       <TargetDirectory>$(SourceDirectory)\AddressBook</TargetDirectory>
     </GeneratedSource>
     <!-- Unit test -->
+    <GeneratedSource Include="$(BuildTempDirectory)\UnitTestExtrasProtoFile.cs">
+      <TargetDirectory>$(SourceDirectory)\ProtocolBuffers.Test\TestProtos</TargetDirectory>
+    </GeneratedSource>
     <GeneratedSource Include="$(BuildTempDirectory)\UnitTestExtrasIssuesProtoFile.cs">
       <TargetDirectory>$(SourceDirectory)\ProtocolBuffers.Test\TestProtos</TargetDirectory>
     </GeneratedSource>

protos/extest/unittest_extras.proto

@@ -0,0 +1,37 @@
+// Additional options required for C# generation. File from copyright
+// line onwards is as per original distribution.
+import "google/protobuf/csharp_options.proto";
+option (google.protobuf.csharp_file_options).namespace = "Google.ProtocolBuffers.TestProtos";
+option (google.protobuf.csharp_file_options).umbrella_classname = "UnitTestExtrasProtoFile";
+option (google.protobuf.csharp_file_options).add_serializable = true;
+
+package protobuf_unittest_extra;
+
+option java_package = "com.google.protobuf";
+
+message TestUnpackedExtensions {
+  extensions 1 to max;
+}
+
+extend TestUnpackedExtensions {
+  repeated    int32 unpacked_int32_extension    =  90;
+  repeated    int64 unpacked_int64_extension    =  91;
+  repeated   uint32 unpacked_uint32_extension   =  92;
+  repeated   uint64 unpacked_uint64_extension   =  93;
+  repeated   sint32 unpacked_sint32_extension   =  94;
+  repeated   sint64 unpacked_sint64_extension   =  95;
+  repeated  fixed32 unpacked_fixed32_extension  =  96;
+  repeated  fixed64 unpacked_fixed64_extension  =  97;
+  repeated sfixed32 unpacked_sfixed32_extension =  98;
+  repeated sfixed64 unpacked_sfixed64_extension =  99;
+  repeated    float unpacked_float_extension    = 100;
+  repeated   double unpacked_double_extension   = 101;
+  repeated     bool unpacked_bool_extension     = 102;
+  repeated UnpackedExtensionsForeignEnum unpacked_enum_extension  = 103;
+}
+
+enum UnpackedExtensionsForeignEnum {
+  FOREIGN_FOO = 4;
+  FOREIGN_BAR = 5;
+  FOREIGN_BAZ = 6;
+}

protos/extest/unittest_extras_lite.proto

@@ -60,3 +60,49 @@ message  TestInteropEmployeeIdLite {
 extend TestInteropPersonLite {
   required TestInteropEmployeeIdLite employee_id_lite = 126;
 }
+
+/* Removed from unittest_lite.proto and added back here */
+
+message TestUnpackedExtensionsLite {
+  extensions 1 to max;
+}
+
+message TestUnpackedTypesLite {
+  repeated    int32 unpacked_int32    =  90;
+  repeated    int64 unpacked_int64    =  91;
+  repeated   uint32 unpacked_uint32   =  92;
+  repeated   uint64 unpacked_uint64   =  93;
+  repeated   sint32 unpacked_sint32   =  94;
+  repeated   sint64 unpacked_sint64   =  95;
+  repeated  fixed32 unpacked_fixed32  =  96;
+  repeated  fixed64 unpacked_fixed64  =  97;
+  repeated sfixed32 unpacked_sfixed32 =  98;
+  repeated sfixed64 unpacked_sfixed64 =  99;
+  repeated    float unpacked_float    = 100;
+  repeated   double unpacked_double   = 101;
+  repeated     bool unpacked_bool     = 102;
+  repeated UnpackedTypesForeignEnumLite unpacked_enum  = 103;
+}
+
+extend TestUnpackedExtensionsLite {
+  repeated    int32 unpacked_int32_extension_lite    =  90;
+  repeated    int64 unpacked_int64_extension_lite    =  91;
+  repeated   uint32 unpacked_uint32_extension_lite   =  92;
+  repeated   uint64 unpacked_uint64_extension_lite   =  93;
+  repeated   sint32 unpacked_sint32_extension_lite   =  94;
+  repeated   sint64 unpacked_sint64_extension_lite   =  95;
+  repeated  fixed32 unpacked_fixed32_extension_lite  =  96;
+  repeated  fixed64 unpacked_fixed64_extension_lite  =  97;
+  repeated sfixed32 unpacked_sfixed32_extension_lite =  98;
+  repeated sfixed64 unpacked_sfixed64_extension_lite =  99;
+  repeated    float unpacked_float_extension_lite    = 100;
+  repeated   double unpacked_double_extension_lite   = 101;
+  repeated     bool unpacked_bool_extension_lite     = 102;
+  repeated UnpackedTypesForeignEnumLite unpacked_enum_extension_lite = 103;
+}
+
+enum UnpackedTypesForeignEnumLite {
+  FOREIGN_LITE_FOO = 4;
+  FOREIGN_LITE_BAR = 5;
+  FOREIGN_LITE_BAZ = 6;
+}

src/ProtocolBuffers.Test/TestProtos/UnitTestCustomOptionsProtoFile.cs

@@ -48,7 +48,16 @@ namespace Google.ProtocolBuffers.TestProtos {
       registry.Add(global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.ComplexOpt2);
       registry.Add(global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.ComplexOpt3);
       registry.Add(global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.ComplexOpt6);
+      registry.Add(global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.Fileopt);
+      registry.Add(global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.Msgopt);
+      registry.Add(global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.Fieldopt);
+      registry.Add(global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.EnumoptRenamed);
+      registry.Add(global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.Enumvalopt);
+      registry.Add(global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.Serviceopt);
+      registry.Add(global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.Methodopt);
       registry.Add(global::Google.ProtocolBuffers.TestProtos.ComplexOptionType2.Types.ComplexOptionType4.ComplexOpt4);
+      registry.Add(global::Google.ProtocolBuffers.TestProtos.AggregateMessageSetElement.MessageSetExtension);
+      registry.Add(global::Google.ProtocolBuffers.TestProtos.Aggregate.Nested);
     }
     #endregion
     #region Extensions
@@ -124,6 +133,20 @@ namespace Google.ProtocolBuffers.TestProtos {
     public static pb::GeneratedExtensionBase<global::Google.ProtocolBuffers.TestProtos.ComplexOptionType3> ComplexOpt3;
     public const int ComplexOpt6FieldNumber = 7595468;
     public static pb::GeneratedExtensionBase<global::Google.ProtocolBuffers.TestProtos.ComplexOpt6> ComplexOpt6;
+    public const int FileoptFieldNumber = 15478479;
+    public static pb::GeneratedExtensionBase<global::Google.ProtocolBuffers.TestProtos.Aggregate> Fileopt;
+    public const int MsgoptFieldNumber = 15480088;
+    public static pb::GeneratedExtensionBase<global::Google.ProtocolBuffers.TestProtos.Aggregate> Msgopt;
+    public const int FieldoptFieldNumber = 15481374;
+    public static pb::GeneratedExtensionBase<global::Google.ProtocolBuffers.TestProtos.Aggregate> Fieldopt;
+    public const int EnumoptRenamedFieldNumber = 15483218;
+    public static pb::GeneratedExtensionBase<global::Google.ProtocolBuffers.TestProtos.Aggregate> EnumoptRenamed;
+    public const int EnumvaloptFieldNumber = 15486921;
+    public static pb::GeneratedExtensionBase<global::Google.ProtocolBuffers.TestProtos.Aggregate> Enumvalopt;
+    public const int ServiceoptFieldNumber = 15497145;
+    public static pb::GeneratedExtensionBase<global::Google.ProtocolBuffers.TestProtos.Aggregate> Serviceopt;
+    public const int MethodoptFieldNumber = 15512713;
+    public static pb::GeneratedExtensionBase<global::Google.ProtocolBuffers.TestProtos.Aggregate> Methodopt;
     #endregion
     
     #region Static variables
@@ -161,6 +184,14 @@ namespace Google.ProtocolBuffers.TestProtos {
     internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.ComplexOpt6, global::Google.ProtocolBuffers.TestProtos.ComplexOpt6.Builder> internal__static_protobuf_unittest_ComplexOpt6__FieldAccessorTable;
     internal static pbd::MessageDescriptor internal__static_protobuf_unittest_VariousComplexOptions__Descriptor;
     internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.VariousComplexOptions, global::Google.ProtocolBuffers.TestProtos.VariousComplexOptions.Builder> internal__static_protobuf_unittest_VariousComplexOptions__FieldAccessorTable;
+    internal static pbd::MessageDescriptor internal__static_protobuf_unittest_AggregateMessageSet__Descriptor;
+    internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.AggregateMessageSet, global::Google.ProtocolBuffers.TestProtos.AggregateMessageSet.Builder> internal__static_protobuf_unittest_AggregateMessageSet__FieldAccessorTable;
+    internal static pbd::MessageDescriptor internal__static_protobuf_unittest_AggregateMessageSetElement__Descriptor;
+    internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.AggregateMessageSetElement, global::Google.ProtocolBuffers.TestProtos.AggregateMessageSetElement.Builder> internal__static_protobuf_unittest_AggregateMessageSetElement__FieldAccessorTable;
+    internal static pbd::MessageDescriptor internal__static_protobuf_unittest_Aggregate__Descriptor;
+    internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.Aggregate, global::Google.ProtocolBuffers.TestProtos.Aggregate.Builder> internal__static_protobuf_unittest_Aggregate__FieldAccessorTable;
+    internal static pbd::MessageDescriptor internal__static_protobuf_unittest_AggregateMessage__Descriptor;
+    internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.AggregateMessage, global::Google.ProtocolBuffers.TestProtos.AggregateMessage.Builder> internal__static_protobuf_unittest_AggregateMessage__FieldAccessorTable;
     #endregion
     #region Descriptor
     public static pbd::FileDescriptor Descriptor {
@@ -209,63 +240,97 @@ namespace Google.ProtocolBuffers.TestProtos {
           "HNKojx0DCLMP+t6QHQIICfrekB0EExgWFKr9kB0DENsHqv2QHQb45pcdjgWq" + 
           "/ZAdBQoDCOcFqv2QHQgKBtiFnh3PD6r9kB0KCgiS9Z0dAwjYD6r9kB0IwqyX" + 
           "HQMI5QWq/ZAdC8Kslx0G2IWeHc4Pqv2QHQ3CrJcdCJL1nR0DCMkQqv2QHQUa" + 
-          "AwjBAqLilR0CCCqi4pUdBtiFnh3EAqLilR0IkvWdHQMI7AYqNgoKTWV0aG9k" + 
-          "T3B0MRITCg9NRVRIT0RPUFQxX1ZBTDEQARITCg9NRVRIT0RPUFQxX1ZBTDIQ" + 
-          "AjKOAQocVGVzdFNlcnZpY2VXaXRoQ3VzdG9tT3B0aW9ucxJjCgNGb28SKS5w" + 
-          "cm90b2J1Zl91bml0dGVzdC5DdXN0b21PcHRpb25Gb29SZXF1ZXN0GioucHJv" + 
-          "dG9idWZfdW5pdHRlc3QuQ3VzdG9tT3B0aW9uRm9vUmVzcG9uc2UiBeD6jB4C" + 
-          "GgmQsose09uAy0k6MgoJZmlsZV9vcHQxEhwuZ29vZ2xlLnByb3RvYnVmLkZp" + 
-          "bGVPcHRpb25zGI6d2AMgASgEOjgKDG1lc3NhZ2Vfb3B0MRIfLmdvb2dsZS5w" + 
-          "cm90b2J1Zi5NZXNzYWdlT3B0aW9ucxicrdgDIAEoBTo0CgpmaWVsZF9vcHQx" + 
-          "Eh0uZ29vZ2xlLnByb3RvYnVmLkZpZWxkT3B0aW9ucxiIvNgDIAEoBjo4Cgpm" + 
-          "aWVsZF9vcHQyEh0uZ29vZ2xlLnByb3RvYnVmLkZpZWxkT3B0aW9ucxi5odkD" + 
-          "IAEoBToCNDI6MgoJZW51bV9vcHQxEhwuZ29vZ2xlLnByb3RvYnVmLkVudW1P" + 
-          "cHRpb25zGOie2QMgASgPOjwKD2VudW1fdmFsdWVfb3B0MRIhLmdvb2dsZS5w" + 
-          "cm90b2J1Zi5FbnVtVmFsdWVPcHRpb25zGOagXyABKAU6OAoMc2VydmljZV9v" + 
-          "cHQxEh8uZ29vZ2xlLnByb3RvYnVmLlNlcnZpY2VPcHRpb25zGKK24QMgASgS" + 
-          "OlUKC21ldGhvZF9vcHQxEh4uZ29vZ2xlLnByb3RvYnVmLk1ldGhvZE9wdGlv" + 
-          "bnMYrM/hAyABKA4yHS5wcm90b2J1Zl91bml0dGVzdC5NZXRob2RPcHQxOjQK" + 
-          "CGJvb2xfb3B0Eh8uZ29vZ2xlLnByb3RvYnVmLk1lc3NhZ2VPcHRpb25zGOqr" + 
-          "1gMgASgIOjUKCWludDMyX29wdBIfLmdvb2dsZS5wcm90b2J1Zi5NZXNzYWdl" + 
-          "T3B0aW9ucxjtqNYDIAEoBTo1CglpbnQ2NF9vcHQSHy5nb29nbGUucHJvdG9i" + 
-          "dWYuTWVzc2FnZU9wdGlvbnMYxqfWAyABKAM6NgoKdWludDMyX29wdBIfLmdv" + 
-          "b2dsZS5wcm90b2J1Zi5NZXNzYWdlT3B0aW9ucxiwotYDIAEoDTo2Cgp1aW50" + 
-          "NjRfb3B0Eh8uZ29vZ2xlLnByb3RvYnVmLk1lc3NhZ2VPcHRpb25zGN+O1gMg" + 
-          "ASgEOjYKCnNpbnQzMl9vcHQSHy5nb29nbGUucHJvdG9idWYuTWVzc2FnZU9w" + 
-          "dGlvbnMYwIjWAyABKBE6NgoKc2ludDY0X29wdBIfLmdvb2dsZS5wcm90b2J1" + 
-          "Zi5NZXNzYWdlT3B0aW9ucxj/gtYDIAEoEjo3CgtmaXhlZDMyX29wdBIfLmdv" + 
-          "b2dsZS5wcm90b2J1Zi5NZXNzYWdlT3B0aW9ucxjT/tUDIAEoBzo3CgtmaXhl" + 
-          "ZDY0X29wdBIfLmdvb2dsZS5wcm90b2J1Zi5NZXNzYWdlT3B0aW9ucxji/dUD" + 
-          "IAEoBjo4CgxzZml4ZWQzMl9vcHQSHy5nb29nbGUucHJvdG9idWYuTWVzc2Fn" + 
-          "ZU9wdGlvbnMY1fHVAyABKA86OAoMc2ZpeGVkNjRfb3B0Eh8uZ29vZ2xlLnBy" + 
-          "b3RvYnVmLk1lc3NhZ2VPcHRpb25zGOOK1QMgASgQOjUKCWZsb2F0X29wdBIf" + 
-          "Lmdvb2dsZS5wcm90b2J1Zi5NZXNzYWdlT3B0aW9ucxj+u9QDIAEoAjo2Cgpk" + 
-          "b3VibGVfb3B0Eh8uZ29vZ2xlLnByb3RvYnVmLk1lc3NhZ2VPcHRpb25zGM2r" + 
-          "1AMgASgBOjYKCnN0cmluZ19vcHQSHy5nb29nbGUucHJvdG9idWYuTWVzc2Fn" + 
-          "ZU9wdGlvbnMYxavUAyABKAk6NQoJYnl0ZXNfb3B0Eh8uZ29vZ2xlLnByb3Rv" + 
-          "YnVmLk1lc3NhZ2VPcHRpb25zGJar1AMgASgMOnAKCGVudW1fb3B0Eh8uZ29v" + 
-          "Z2xlLnByb3RvYnVmLk1lc3NhZ2VPcHRpb25zGJGr1AMgASgOMjoucHJvdG9i" + 
-          "dWZfdW5pdHRlc3QuRHVtbXlNZXNzYWdlQ29udGFpbmluZ0VudW0uVGVzdEVu" + 
-          "dW1UeXBlOnAKEG1lc3NhZ2VfdHlwZV9vcHQSHy5nb29nbGUucHJvdG9idWYu" + 
-          "TWVzc2FnZU9wdGlvbnMYr/LTAyABKAsyMi5wcm90b2J1Zl91bml0dGVzdC5E" + 
-          "dW1teU1lc3NhZ2VJbnZhbGlkQXNPcHRpb25UeXBlOjYKBHF1dXgSJS5wcm90" + 
-          "b2J1Zl91bml0dGVzdC5Db21wbGV4T3B0aW9uVHlwZTEY2+DTAyABKAU6XgoF" + 
-          "Y29yZ2USJS5wcm90b2J1Zl91bml0dGVzdC5Db21wbGV4T3B0aW9uVHlwZTEY" + 
-          "0t7TAyABKAsyJS5wcm90b2J1Zl91bml0dGVzdC5Db21wbGV4T3B0aW9uVHlw" + 
-          "ZTM6OAoGZ3JhdWx0EiUucHJvdG9idWZfdW5pdHRlc3QuQ29tcGxleE9wdGlv" + 
-          "blR5cGUyGO/80gMgASgFOl8KBmdhcnBseRIlLnByb3RvYnVmX3VuaXR0ZXN0" + 
-          "LkNvbXBsZXhPcHRpb25UeXBlMhjI9dIDIAEoCzIlLnByb3RvYnVmX3VuaXR0" + 
-          "ZXN0LkNvbXBsZXhPcHRpb25UeXBlMTpfCgxjb21wbGV4X29wdDESHy5nb29n" + 
-          "bGUucHJvdG9idWYuTWVzc2FnZU9wdGlvbnMYpNzSAyABKAsyJS5wcm90b2J1" + 
-          "Zl91bml0dGVzdC5Db21wbGV4T3B0aW9uVHlwZTE6XwoMY29tcGxleF9vcHQy" + 
-          "Eh8uZ29vZ2xlLnByb3RvYnVmLk1lc3NhZ2VPcHRpb25zGNWP0gMgASgLMiUu" + 
-          "cHJvdG9idWZfdW5pdHRlc3QuQ29tcGxleE9wdGlvblR5cGUyOl8KDGNvbXBs" + 
-          "ZXhfb3B0MxIfLmdvb2dsZS5wcm90b2J1Zi5NZXNzYWdlT3B0aW9ucxjvi9ID" + 
-          "IAEoCzIlLnByb3RvYnVmX3VuaXR0ZXN0LkNvbXBsZXhPcHRpb25UeXBlMzpX" + 
-          "Cgtjb21wbGV4b3B0NhIfLmdvb2dsZS5wcm90b2J1Zi5NZXNzYWdlT3B0aW9u" + 
-          "cxjMy88DIAEoCjIeLnByb3RvYnVmX3VuaXR0ZXN0LkNvbXBsZXhPcHQ2Qk/C" + 
-          "PkMKIUdvb2dsZS5Qcm90b2NvbEJ1ZmZlcnMuVGVzdFByb3RvcxIeVW5pdFRl" + 
-          "c3RDdXN0b21PcHRpb25zUHJvdG9GaWxl8OjBHeqtwOUk");
+          "AwjBAqLilR0CCCqi4pUdBtiFnh3EAqLilR0IkvWdHQMI7AYiIwoTQWdncmVn" + 
+          "YXRlTWVzc2FnZVNldCoICAQQgICAgAI6AggBIqABChpBZ2dyZWdhdGVNZXNz" + 
+          "YWdlU2V0RWxlbWVudBIJCgFzGAEgASgJMncKFW1lc3NhZ2Vfc2V0X2V4dGVu" + 
+          "c2lvbhImLnByb3RvYnVmX3VuaXR0ZXN0LkFnZ3JlZ2F0ZU1lc3NhZ2VTZXQY" + 
+          "9uuuByABKAsyLS5wcm90b2J1Zl91bml0dGVzdC5BZ2dyZWdhdGVNZXNzYWdl" + 
+          "U2V0RWxlbWVudCL9AQoJQWdncmVnYXRlEgkKAWkYASABKAUSCQoBcxgCIAEo" + 
+          "CRIpCgNzdWIYAyABKAsyHC5wcm90b2J1Zl91bml0dGVzdC5BZ2dyZWdhdGUS" + 
+          "KgoEZmlsZRgEIAEoCzIcLmdvb2dsZS5wcm90b2J1Zi5GaWxlT3B0aW9ucxI0" + 
+          "CgRtc2V0GAUgASgLMiYucHJvdG9idWZfdW5pdHRlc3QuQWdncmVnYXRlTWVz" + 
+          "c2FnZVNldDJNCgZuZXN0ZWQSHC5nb29nbGUucHJvdG9idWYuRmlsZU9wdGlv" + 
+          "bnMYp9GwByABKAsyHC5wcm90b2J1Zl91bml0dGVzdC5BZ2dyZWdhdGUiWQoQ" + 
+          "QWdncmVnYXRlTWVzc2FnZRIpCglmaWVsZG5hbWUYASABKAVCFvKhhzsREg9G" + 
+          "aWVsZEFubm90YXRpb246GsLRhjsVCGUSEU1lc3NhZ2VBbm5vdGF0aW9uKjYK" + 
+          "Ck1ldGhvZE9wdDESEwoPTUVUSE9ET1BUMV9WQUwxEAESEwoPTUVUSE9ET1BU" + 
+          "MV9WQUwyEAIqTQoNQWdncmVnYXRlRW51bRIlCgVWQUxVRRABGhrK/Ik7FRIT" + 
+          "RW51bVZhbHVlQW5ub3RhdGlvbhoVkpWIOxASDkVudW1Bbm5vdGF0aW9uMo4B" + 
+          "ChxUZXN0U2VydmljZVdpdGhDdXN0b21PcHRpb25zEmMKA0ZvbxIpLnByb3Rv" + 
+          "YnVmX3VuaXR0ZXN0LkN1c3RvbU9wdGlvbkZvb1JlcXVlc3QaKi5wcm90b2J1" + 
+          "Zl91bml0dGVzdC5DdXN0b21PcHRpb25Gb29SZXNwb25zZSIF4PqMHgIaCZCy" + 
+          "ix7T24DLSTKZAQoQQWdncmVnYXRlU2VydmljZRJrCgZNZXRob2QSIy5wcm90" + 
+          "b2J1Zl91bml0dGVzdC5BZ2dyZWdhdGVNZXNzYWdlGiMucHJvdG9idWZfdW5p" + 
+          "dHRlc3QuQWdncmVnYXRlTWVzc2FnZSIXysiWOxISEE1ldGhvZEFubm90YXRp" + 
+          "b24aGMr7jjsTEhFTZXJ2aWNlQW5ub3RhdGlvbjoyCglmaWxlX29wdDESHC5n" + 
+          "b29nbGUucHJvdG9idWYuRmlsZU9wdGlvbnMYjp3YAyABKAQ6OAoMbWVzc2Fn" + 
+          "ZV9vcHQxEh8uZ29vZ2xlLnByb3RvYnVmLk1lc3NhZ2VPcHRpb25zGJyt2AMg" + 
+          "ASgFOjQKCmZpZWxkX29wdDESHS5nb29nbGUucHJvdG9idWYuRmllbGRPcHRp" + 
+          "b25zGIi82AMgASgGOjgKCmZpZWxkX29wdDISHS5nb29nbGUucHJvdG9idWYu" + 
+          "RmllbGRPcHRpb25zGLmh2QMgASgFOgI0MjoyCgllbnVtX29wdDESHC5nb29n" + 
+          "bGUucHJvdG9idWYuRW51bU9wdGlvbnMY6J7ZAyABKA86PAoPZW51bV92YWx1" + 
+          "ZV9vcHQxEiEuZ29vZ2xlLnByb3RvYnVmLkVudW1WYWx1ZU9wdGlvbnMY5qBf" + 
+          "IAEoBTo4CgxzZXJ2aWNlX29wdDESHy5nb29nbGUucHJvdG9idWYuU2Vydmlj" + 
+          "ZU9wdGlvbnMYorbhAyABKBI6VQoLbWV0aG9kX29wdDESHi5nb29nbGUucHJv" + 
+          "dG9idWYuTWV0aG9kT3B0aW9ucxisz+EDIAEoDjIdLnByb3RvYnVmX3VuaXR0" + 
+          "ZXN0Lk1ldGhvZE9wdDE6NAoIYm9vbF9vcHQSHy5nb29nbGUucHJvdG9idWYu" + 
+          "TWVzc2FnZU9wdGlvbnMY6qvWAyABKAg6NQoJaW50MzJfb3B0Eh8uZ29vZ2xl" + 
+          "LnByb3RvYnVmLk1lc3NhZ2VPcHRpb25zGO2o1gMgASgFOjUKCWludDY0X29w" + 
+          "dBIfLmdvb2dsZS5wcm90b2J1Zi5NZXNzYWdlT3B0aW9ucxjGp9YDIAEoAzo2" + 
+          "Cgp1aW50MzJfb3B0Eh8uZ29vZ2xlLnByb3RvYnVmLk1lc3NhZ2VPcHRpb25z" + 
+          "GLCi1gMgASgNOjYKCnVpbnQ2NF9vcHQSHy5nb29nbGUucHJvdG9idWYuTWVz" + 
+          "c2FnZU9wdGlvbnMY347WAyABKAQ6NgoKc2ludDMyX29wdBIfLmdvb2dsZS5w" + 
+          "cm90b2J1Zi5NZXNzYWdlT3B0aW9ucxjAiNYDIAEoETo2CgpzaW50NjRfb3B0" + 
+          "Eh8uZ29vZ2xlLnByb3RvYnVmLk1lc3NhZ2VPcHRpb25zGP+C1gMgASgSOjcK" + 
+          "C2ZpeGVkMzJfb3B0Eh8uZ29vZ2xlLnByb3RvYnVmLk1lc3NhZ2VPcHRpb25z" + 
+          "GNP+1QMgASgHOjcKC2ZpeGVkNjRfb3B0Eh8uZ29vZ2xlLnByb3RvYnVmLk1l" + 
+          "c3NhZ2VPcHRpb25zGOL91QMgASgGOjgKDHNmaXhlZDMyX29wdBIfLmdvb2ds" + 
+          "ZS5wcm90b2J1Zi5NZXNzYWdlT3B0aW9ucxjV8dUDIAEoDzo4CgxzZml4ZWQ2" + 
+          "NF9vcHQSHy5nb29nbGUucHJvdG9idWYuTWVzc2FnZU9wdGlvbnMY44rVAyAB" + 
+          "KBA6NQoJZmxvYXRfb3B0Eh8uZ29vZ2xlLnByb3RvYnVmLk1lc3NhZ2VPcHRp" + 
+          "b25zGP671AMgASgCOjYKCmRvdWJsZV9vcHQSHy5nb29nbGUucHJvdG9idWYu" + 
+          "TWVzc2FnZU9wdGlvbnMYzavUAyABKAE6NgoKc3RyaW5nX29wdBIfLmdvb2ds" + 
+          "ZS5wcm90b2J1Zi5NZXNzYWdlT3B0aW9ucxjFq9QDIAEoCTo1CglieXRlc19v" + 
+          "cHQSHy5nb29nbGUucHJvdG9idWYuTWVzc2FnZU9wdGlvbnMYlqvUAyABKAw6" + 
+          "cAoIZW51bV9vcHQSHy5nb29nbGUucHJvdG9idWYuTWVzc2FnZU9wdGlvbnMY" + 
+          "kavUAyABKA4yOi5wcm90b2J1Zl91bml0dGVzdC5EdW1teU1lc3NhZ2VDb250" + 
+          "YWluaW5nRW51bS5UZXN0RW51bVR5cGU6cAoQbWVzc2FnZV90eXBlX29wdBIf" + 
+          "Lmdvb2dsZS5wcm90b2J1Zi5NZXNzYWdlT3B0aW9ucxiv8tMDIAEoCzIyLnBy" + 
+          "b3RvYnVmX3VuaXR0ZXN0LkR1bW15TWVzc2FnZUludmFsaWRBc09wdGlvblR5" + 
+          "cGU6NgoEcXV1eBIlLnByb3RvYnVmX3VuaXR0ZXN0LkNvbXBsZXhPcHRpb25U" + 
+          "eXBlMRjb4NMDIAEoBTpeCgVjb3JnZRIlLnByb3RvYnVmX3VuaXR0ZXN0LkNv" + 
+          "bXBsZXhPcHRpb25UeXBlMRjS3tMDIAEoCzIlLnByb3RvYnVmX3VuaXR0ZXN0" + 
+          "LkNvbXBsZXhPcHRpb25UeXBlMzo4CgZncmF1bHQSJS5wcm90b2J1Zl91bml0" + 
+          "dGVzdC5Db21wbGV4T3B0aW9uVHlwZTIY7/zSAyABKAU6XwoGZ2FycGx5EiUu" + 
+          "cHJvdG9idWZfdW5pdHRlc3QuQ29tcGxleE9wdGlvblR5cGUyGMj10gMgASgL" + 
+          "MiUucHJvdG9idWZfdW5pdHRlc3QuQ29tcGxleE9wdGlvblR5cGUxOl8KDGNv" + 
+          "bXBsZXhfb3B0MRIfLmdvb2dsZS5wcm90b2J1Zi5NZXNzYWdlT3B0aW9ucxik" + 
+          "3NIDIAEoCzIlLnByb3RvYnVmX3VuaXR0ZXN0LkNvbXBsZXhPcHRpb25UeXBl" + 
+          "MTpfCgxjb21wbGV4X29wdDISHy5nb29nbGUucHJvdG9idWYuTWVzc2FnZU9w" + 
+          "dGlvbnMY1Y/SAyABKAsyJS5wcm90b2J1Zl91bml0dGVzdC5Db21wbGV4T3B0" + 
+          "aW9uVHlwZTI6XwoMY29tcGxleF9vcHQzEh8uZ29vZ2xlLnByb3RvYnVmLk1l" + 
+          "c3NhZ2VPcHRpb25zGO+L0gMgASgLMiUucHJvdG9idWZfdW5pdHRlc3QuQ29t" + 
+          "cGxleE9wdGlvblR5cGUzOlcKC2NvbXBsZXhvcHQ2Eh8uZ29vZ2xlLnByb3Rv" + 
+          "YnVmLk1lc3NhZ2VPcHRpb25zGMzLzwMgASgKMh4ucHJvdG9idWZfdW5pdHRl" + 
+          "c3QuQ29tcGxleE9wdDY6TgoHZmlsZW9wdBIcLmdvb2dsZS5wcm90b2J1Zi5G" + 
+          "aWxlT3B0aW9ucxjP3bAHIAEoCzIcLnByb3RvYnVmX3VuaXR0ZXN0LkFnZ3Jl" + 
+          "Z2F0ZTpQCgZtc2dvcHQSHy5nb29nbGUucHJvdG9idWYuTWVzc2FnZU9wdGlv" + 
+          "bnMYmOqwByABKAsyHC5wcm90b2J1Zl91bml0dGVzdC5BZ2dyZWdhdGU6UAoI" + 
+          "ZmllbGRvcHQSHS5nb29nbGUucHJvdG9idWYuRmllbGRPcHRpb25zGJ70sAcg" + 
+          "ASgLMhwucHJvdG9idWZfdW5pdHRlc3QuQWdncmVnYXRlOlYKD2VudW1vcHRf" + 
+          "cmVuYW1lZBIcLmdvb2dsZS5wcm90b2J1Zi5FbnVtT3B0aW9ucxjSgrEHIAEo" + 
+          "CzIcLnByb3RvYnVmX3VuaXR0ZXN0LkFnZ3JlZ2F0ZTpWCgplbnVtdmFsb3B0" + 
+          "EiEuZ29vZ2xlLnByb3RvYnVmLkVudW1WYWx1ZU9wdGlvbnMYyZ+xByABKAsy" + 
+          "HC5wcm90b2J1Zl91bml0dGVzdC5BZ2dyZWdhdGU6VAoKc2VydmljZW9wdBIf" + 
+          "Lmdvb2dsZS5wcm90b2J1Zi5TZXJ2aWNlT3B0aW9ucxi577EHIAEoCzIcLnBy" + 
+          "b3RvYnVmX3VuaXR0ZXN0LkFnZ3JlZ2F0ZTpSCgltZXRob2RvcHQSHi5nb29n" + 
+          "bGUucHJvdG9idWYuTWV0aG9kT3B0aW9ucxiJ6bIHIAEoCzIcLnByb3RvYnVm" + 
+          "X3VuaXR0ZXN0LkFnZ3JlZ2F0ZULNAYABAYgBAZABAcI+QwohR29vZ2xlLlBy" + 
+          "b3RvY29sQnVmZmVycy5UZXN0UHJvdG9zEh5Vbml0VGVzdEN1c3RvbU9wdGlv" + 
+          "bnNQcm90b0ZpbGXw6MEd6q3A5ST67IU7cAhkEg5GaWxlQW5ub3RhdGlvbhoW" + 
+          "EhROZXN0ZWRGaWxlQW5ub3RhdGlvbiIe+uyFOxkSF0ZpbGVFeHRlbnNpb25B" + 
+          "bm5vdGF0aW9uKiQLEPbrrgcaGwoZRW1iZWRkZWRNZXNzYWdlU2V0RWxlbWVu" + 
+          "dAw=");
       pbd::FileDescriptor.InternalDescriptorAssigner assigner = delegate(pbd::FileDescriptor root) {
         descriptor = root;
         internal__static_protobuf_unittest_TestMessageWithCustomOptions__Descriptor = Descriptor.MessageTypes[0];
@@ -337,6 +402,24 @@ namespace Google.ProtocolBuffers.TestProtos {
         internal__static_protobuf_unittest_VariousComplexOptions__FieldAccessorTable = 
             new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.VariousComplexOptions, global::Google.ProtocolBuffers.TestProtos.VariousComplexOptions.Builder>(internal__static_protobuf_unittest_VariousComplexOptions__Descriptor,
                 new string[] { });
+        internal__static_protobuf_unittest_AggregateMessageSet__Descriptor = Descriptor.MessageTypes[15];
+        internal__static_protobuf_unittest_AggregateMessageSet__FieldAccessorTable = 
+            new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.AggregateMessageSet, global::Google.ProtocolBuffers.TestProtos.AggregateMessageSet.Builder>(internal__static_protobuf_unittest_AggregateMessageSet__Descriptor,
+                new string[] { });
+        internal__static_protobuf_unittest_AggregateMessageSetElement__Descriptor = Descriptor.MessageTypes[16];
+        internal__static_protobuf_unittest_AggregateMessageSetElement__FieldAccessorTable = 
+            new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.AggregateMessageSetElement, global::Google.ProtocolBuffers.TestProtos.AggregateMessageSetElement.Builder>(internal__static_protobuf_unittest_AggregateMessageSetElement__Descriptor,
+                new string[] { "S", });
+        global::Google.ProtocolBuffers.TestProtos.AggregateMessageSetElement.MessageSetExtension = pb::GeneratedSingleExtension<global::Google.ProtocolBuffers.TestProtos.AggregateMessageSetElement>.CreateInstance(global::Google.ProtocolBuffers.TestProtos.AggregateMessageSetElement.Descriptor.Extensions[0]);
+        internal__static_protobuf_unittest_Aggregate__Descriptor = Descriptor.MessageTypes[17];
+        internal__static_protobuf_unittest_Aggregate__FieldAccessorTable = 
+            new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.Aggregate, global::Google.ProtocolBuffers.TestProtos.Aggregate.Builder>(internal__static_protobuf_unittest_Aggregate__Descriptor,
+                new string[] { "I", "S", "Sub", "File", "Mset", });
+        global::Google.ProtocolBuffers.TestProtos.Aggregate.Nested = pb::GeneratedSingleExtension<global::Google.ProtocolBuffers.TestProtos.Aggregate>.CreateInstance(global::Google.ProtocolBuffers.TestProtos.Aggregate.Descriptor.Extensions[0]);
+        internal__static_protobuf_unittest_AggregateMessage__Descriptor = Descriptor.MessageTypes[18];
+        internal__static_protobuf_unittest_AggregateMessage__FieldAccessorTable = 
+            new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.AggregateMessage, global::Google.ProtocolBuffers.TestProtos.AggregateMessage.Builder>(internal__static_protobuf_unittest_AggregateMessage__Descriptor,
+                new string[] { "Fieldname", });
         global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.FileOpt1 = pb::GeneratedSingleExtension<ulong>.CreateInstance(global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.Descriptor.Extensions[0]);
         global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.MessageOpt1 = pb::GeneratedSingleExtension<int>.CreateInstance(global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.Descriptor.Extensions[1]);
         global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.FieldOpt1 = pb::GeneratedSingleExtension<ulong>.CreateInstance(global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.Descriptor.Extensions[2]);
@@ -370,6 +453,13 @@ namespace Google.ProtocolBuffers.TestProtos {
         global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.ComplexOpt2 = pb::GeneratedSingleExtension<global::Google.ProtocolBuffers.TestProtos.ComplexOptionType2>.CreateInstance(global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.Descriptor.Extensions[30]);
         global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.ComplexOpt3 = pb::GeneratedSingleExtension<global::Google.ProtocolBuffers.TestProtos.ComplexOptionType3>.CreateInstance(global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.Descriptor.Extensions[31]);
         global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.ComplexOpt6 = pb::GeneratedSingleExtension<global::Google.ProtocolBuffers.TestProtos.ComplexOpt6>.CreateInstance(global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.Descriptor.Extensions[32]);
+        global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.Fileopt = pb::GeneratedSingleExtension<global::Google.ProtocolBuffers.TestProtos.Aggregate>.CreateInstance(global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.Descriptor.Extensions[33]);
+        global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.Msgopt = pb::GeneratedSingleExtension<global::Google.ProtocolBuffers.TestProtos.Aggregate>.CreateInstance(global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.Descriptor.Extensions[34]);
+        global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.Fieldopt = pb::GeneratedSingleExtension<global::Google.ProtocolBuffers.TestProtos.Aggregate>.CreateInstance(global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.Descriptor.Extensions[35]);
+        global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.EnumoptRenamed = pb::GeneratedSingleExtension<global::Google.ProtocolBuffers.TestProtos.Aggregate>.CreateInstance(global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.Descriptor.Extensions[36]);
+        global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.Enumvalopt = pb::GeneratedSingleExtension<global::Google.ProtocolBuffers.TestProtos.Aggregate>.CreateInstance(global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.Descriptor.Extensions[37]);
+        global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.Serviceopt = pb::GeneratedSingleExtension<global::Google.ProtocolBuffers.TestProtos.Aggregate>.CreateInstance(global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.Descriptor.Extensions[38]);
+        global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.Methodopt = pb::GeneratedSingleExtension<global::Google.ProtocolBuffers.TestProtos.Aggregate>.CreateInstance(global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.Descriptor.Extensions[39]);
         pb::ExtensionRegistry registry = pb::ExtensionRegistry.CreateInstance();
         RegisterAllExtensions(registry);
         global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.RegisterAllExtensions(registry);
@@ -393,6 +483,12 @@ namespace Google.ProtocolBuffers.TestProtos {
     METHODOPT1_VAL2 = 2,
   }
   
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+  [global::System.CodeDom.Compiler.GeneratedCodeAttribute("ProtoGen", "2.3.0.277")]
+  public enum AggregateEnum {
+    VALUE = 1,
+  }
+  
   #endregion
   
   #region Messages
@@ -4976,9 +5072,1330 @@ namespace Google.ProtocolBuffers.TestProtos {
     }
   }
   
-  #endregion
+  [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+  [global::System.CodeDom.Compiler.GeneratedCodeAttribute("ProtoGen", "2.3.0.277")]
+  public sealed partial class AggregateMessageSet : pb::ExtendableMessage<AggregateMessageSet, AggregateMessageSet.Builder> {
+    private AggregateMessageSet() { }
+    private static readonly AggregateMessageSet defaultInstance = new AggregateMessageSet().MakeReadOnly();
+    private static readonly string[] _aggregateMessageSetFieldNames = new string[] {  };
+    private static readonly uint[] _aggregateMessageSetFieldTags = new uint[] {  };
+    public static AggregateMessageSet DefaultInstance {
+      get { return defaultInstance; }
+    }
+    
+    public override AggregateMessageSet DefaultInstanceForType {
+      get { return DefaultInstance; }
+    }
+    
+    protected override AggregateMessageSet ThisMessage {
+      get { return this; }
+    }
+    
+    public static pbd::MessageDescriptor Descriptor {
+      get { return global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.internal__static_protobuf_unittest_AggregateMessageSet__Descriptor; }
+    }
+    
+    protected override pb::FieldAccess.FieldAccessorTable<AggregateMessageSet, AggregateMessageSet.Builder> InternalFieldAccessors {
+      get { return global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.internal__static_protobuf_unittest_AggregateMessageSet__FieldAccessorTable; }
+    }
+    
+    public override bool IsInitialized {
+      get {
+        if (!ExtensionsAreInitialized) return false;
+        return true;
+      }
+    }
+    
+    public override void WriteTo(pb::ICodedOutputStream output) {
+      int size = SerializedSize;
+      string[] field_names = _aggregateMessageSetFieldNames;
+      pb::ExtendableMessage<AggregateMessageSet, AggregateMessageSet.Builder>.ExtensionWriter extensionWriter = CreateExtensionWriter(this);
+      extensionWriter.WriteUntil(536870912, output);
+      UnknownFields.WriteAsMessageSetTo(output);
+    }
+    
+    private int memoizedSerializedSize = -1;
+    public override int SerializedSize {
+      get {
+        int size = memoizedSerializedSize;
+        if (size != -1) return size;
+        
+        size = 0;
+        size += ExtensionsSerializedSize;
+        size += UnknownFields.SerializedSizeAsMessageSet;
+        memoizedSerializedSize = size;
+        return size;
+      }
+    }
+    
+    public static AggregateMessageSet ParseFrom(pb::ByteString data) {
+      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
+    }
+    public static AggregateMessageSet ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
+    }
+    public static AggregateMessageSet ParseFrom(byte[] data) {
+      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
+    }
+    public static AggregateMessageSet ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
+    }
+    public static AggregateMessageSet ParseFrom(global::System.IO.Stream input) {
+      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
+    }
+    public static AggregateMessageSet ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
+    }
+    public static AggregateMessageSet ParseDelimitedFrom(global::System.IO.Stream input) {
+      return CreateBuilder().MergeDelimitedFrom(input).BuildParsed();
+    }
+    public static AggregateMessageSet ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
+      return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed();
+    }
+    public static AggregateMessageSet ParseFrom(pb::ICodedInputStream input) {
+      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
+    }
+    public static AggregateMessageSet ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
+    }
+    private AggregateMessageSet MakeReadOnly() {
+      return this;
+    }
+    
+    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(AggregateMessageSet prototype) {
+      return new Builder(prototype);
+    }
+    
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("ProtoGen", "2.3.0.277")]
+    public sealed partial class Builder : pb::ExtendableBuilder<AggregateMessageSet, Builder> {
+      protected override Builder ThisBuilder {
+        get { return this; }
+      }
+      public Builder() {
+        result = DefaultInstance;
+        resultIsReadOnly = true;
+      }
+      internal Builder(AggregateMessageSet cloneFrom) {
+        result = cloneFrom;
+        resultIsReadOnly = true;
+      }
+      
+      private bool resultIsReadOnly;
+      private AggregateMessageSet result;
+      
+      private AggregateMessageSet PrepareBuilder() {
+        if (resultIsReadOnly) {
+          AggregateMessageSet original = result;
+          result = new AggregateMessageSet();
+          resultIsReadOnly = false;
+          MergeFrom(original);
+        }
+        return result;
+      }
+      
+      public override bool IsInitialized {
+        get { return result.IsInitialized; }
+      }
+      
+      protected override AggregateMessageSet MessageBeingBuilt {
+        get { return PrepareBuilder(); }
+      }
+      
+      public override Builder Clear() {
+        result = DefaultInstance;
+        resultIsReadOnly = true;
+        return this;
+      }
+      
+      public override Builder Clone() {
+        if (resultIsReadOnly) {
+          return new Builder(result);
+        } else {
+          return new Builder().MergeFrom(result);
+        }
+      }
+      
+      public override pbd::MessageDescriptor DescriptorForType {
+        get { return global::Google.ProtocolBuffers.TestProtos.AggregateMessageSet.Descriptor; }
+      }
+      
+      public override AggregateMessageSet DefaultInstanceForType {
+        get { return global::Google.ProtocolBuffers.TestProtos.AggregateMessageSet.DefaultInstance; }
+      }
+      
+      public override AggregateMessageSet BuildPartial() {
+        if (resultIsReadOnly) {
+          return result;
+        }
+        resultIsReadOnly = true;
+        return result.MakeReadOnly();
+      }
+      
+      public override Builder MergeFrom(pb::IMessage other) {
+        if (other is AggregateMessageSet) {
+          return MergeFrom((AggregateMessageSet) other);
+        } else {
+          base.MergeFrom(other);
+          return this;
+        }
+      }
+      
+      public override Builder MergeFrom(AggregateMessageSet other) {
+        if (other == global::Google.ProtocolBuffers.TestProtos.AggregateMessageSet.DefaultInstance) return this;
+        PrepareBuilder();
+          this.MergeExtensionFields(other);
+        this.MergeUnknownFields(other.UnknownFields);
+        return this;
+      }
+      
+      public override Builder MergeFrom(pb::ICodedInputStream input) {
+        return MergeFrom(input, pb::ExtensionRegistry.Empty);
+      }
+      
+      public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
+        PrepareBuilder();
+        pb::UnknownFieldSet.Builder unknownFields = null;
+        uint tag;
+        string field_name;
+        while (input.ReadTag(out tag, out field_name)) {
+          if(tag == 0 && field_name != null) {
+            int field_ordinal = global::System.Array.BinarySearch(_aggregateMessageSetFieldNames, field_name, global::System.StringComparer.Ordinal);
+            if(field_ordinal >= 0)
+              tag = _aggregateMessageSetFieldTags[field_ordinal];
+            else {
+              if (unknownFields == null) {
+                unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
+              }
+              ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
+              continue;
+            }
+          }
+          switch (tag) {
+            case 0: {
+              throw pb::InvalidProtocolBufferException.InvalidTag();
+            }
+            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, field_name);
+              break;
+            }
+          }
+        }
+        
+        if (unknownFields != null) {
+          this.UnknownFields = unknownFields.Build();
+        }
+        return this;
+      }
+      
+    }
+    static AggregateMessageSet() {
+      object.ReferenceEquals(global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.Descriptor, null);
+    }
+  }
   
-  #region Services
+  [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+  [global::System.CodeDom.Compiler.GeneratedCodeAttribute("ProtoGen", "2.3.0.277")]
+  public sealed partial class AggregateMessageSetElement : pb::GeneratedMessage<AggregateMessageSetElement, AggregateMessageSetElement.Builder> {
+    private AggregateMessageSetElement() { }
+    private static readonly AggregateMessageSetElement defaultInstance = new AggregateMessageSetElement().MakeReadOnly();
+    private static readonly string[] _aggregateMessageSetElementFieldNames = new string[] { "s" };
+    private static readonly uint[] _aggregateMessageSetElementFieldTags = new uint[] { 10 };
+    public static AggregateMessageSetElement DefaultInstance {
+      get { return defaultInstance; }
+    }
+    
+    public override AggregateMessageSetElement DefaultInstanceForType {
+      get { return DefaultInstance; }
+    }
+    
+    protected override AggregateMessageSetElement ThisMessage {
+      get { return this; }
+    }
+    
+    public static pbd::MessageDescriptor Descriptor {
+      get { return global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.internal__static_protobuf_unittest_AggregateMessageSetElement__Descriptor; }
+    }
+    
+    protected override pb::FieldAccess.FieldAccessorTable<AggregateMessageSetElement, AggregateMessageSetElement.Builder> InternalFieldAccessors {
+      get { return global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.internal__static_protobuf_unittest_AggregateMessageSetElement__FieldAccessorTable; }
+    }
+    
+    public const int MessageSetExtensionFieldNumber = 15447542;
+    public static pb::GeneratedExtensionBase<global::Google.ProtocolBuffers.TestProtos.AggregateMessageSetElement> MessageSetExtension;
+    public const int SFieldNumber = 1;
+    private bool hasS;
+    private string s_ = "";
+    public bool HasS {
+      get { return hasS; }
+    }
+    public string S {
+      get { return s_; }
+    }
+    
+    public override bool IsInitialized {
+      get {
+        return true;
+      }
+    }
+    
+    public override void WriteTo(pb::ICodedOutputStream output) {
+      int size = SerializedSize;
+      string[] field_names = _aggregateMessageSetElementFieldNames;
+      if (hasS) {
+        output.WriteString(1, field_names[0], S);
+      }
+      UnknownFields.WriteTo(output);
+    }
+    
+    private int memoizedSerializedSize = -1;
+    public override int SerializedSize {
+      get {
+        int size = memoizedSerializedSize;
+        if (size != -1) return size;
+        
+        size = 0;
+        if (hasS) {
+          size += pb::CodedOutputStream.ComputeStringSize(1, S);
+        }
+        size += UnknownFields.SerializedSize;
+        memoizedSerializedSize = size;
+        return size;
+      }
+    }
+    
+    public static AggregateMessageSetElement ParseFrom(pb::ByteString data) {
+      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
+    }
+    public static AggregateMessageSetElement ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
+    }
+    public static AggregateMessageSetElement ParseFrom(byte[] data) {
+      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
+    }
+    public static AggregateMessageSetElement ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
+    }
+    public static AggregateMessageSetElement ParseFrom(global::System.IO.Stream input) {
+      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
+    }
+    public static AggregateMessageSetElement ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
+    }
+    public static AggregateMessageSetElement ParseDelimitedFrom(global::System.IO.Stream input) {
+      return CreateBuilder().MergeDelimitedFrom(input).BuildParsed();
+    }
+    public static AggregateMessageSetElement ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
+      return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed();
+    }
+    public static AggregateMessageSetElement ParseFrom(pb::ICodedInputStream input) {
+      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
+    }
+    public static AggregateMessageSetElement ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
+    }
+    private AggregateMessageSetElement MakeReadOnly() {
+      return this;
+    }
+    
+    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(AggregateMessageSetElement prototype) {
+      return new Builder(prototype);
+    }
+    
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("ProtoGen", "2.3.0.277")]
+    public sealed partial class Builder : pb::GeneratedBuilder<AggregateMessageSetElement, Builder> {
+      protected override Builder ThisBuilder {
+        get { return this; }
+      }
+      public Builder() {
+        result = DefaultInstance;
+        resultIsReadOnly = true;
+      }
+      internal Builder(AggregateMessageSetElement cloneFrom) {
+        result = cloneFrom;
+        resultIsReadOnly = true;
+      }
+      
+      private bool resultIsReadOnly;
+      private AggregateMessageSetElement result;
+      
+      private AggregateMessageSetElement PrepareBuilder() {
+        if (resultIsReadOnly) {
+          AggregateMessageSetElement original = result;
+          result = new AggregateMessageSetElement();
+          resultIsReadOnly = false;
+          MergeFrom(original);
+        }
+        return result;
+      }
+      
+      public override bool IsInitialized {
+        get { return result.IsInitialized; }
+      }
+      
+      protected override AggregateMessageSetElement MessageBeingBuilt {
+        get { return PrepareBuilder(); }
+      }
+      
+      public override Builder Clear() {
+        result = DefaultInstance;
+        resultIsReadOnly = true;
+        return this;
+      }
+      
+      public override Builder Clone() {
+        if (resultIsReadOnly) {
+          return new Builder(result);
+        } else {
+          return new Builder().MergeFrom(result);
+        }
+      }
+      
+      public override pbd::MessageDescriptor DescriptorForType {
+        get { return global::Google.ProtocolBuffers.TestProtos.AggregateMessageSetElement.Descriptor; }
+      }
+      
+      public override AggregateMessageSetElement DefaultInstanceForType {
+        get { return global::Google.ProtocolBuffers.TestProtos.AggregateMessageSetElement.DefaultInstance; }
+      }
+      
+      public override AggregateMessageSetElement BuildPartial() {
+        if (resultIsReadOnly) {
+          return result;
+        }
+        resultIsReadOnly = true;
+        return result.MakeReadOnly();
+      }
+      
+      public override Builder MergeFrom(pb::IMessage other) {
+        if (other is AggregateMessageSetElement) {
+          return MergeFrom((AggregateMessageSetElement) other);
+        } else {
+          base.MergeFrom(other);
+          return this;
+        }
+      }
+      
+      public override Builder MergeFrom(AggregateMessageSetElement other) {
+        if (other == global::Google.ProtocolBuffers.TestProtos.AggregateMessageSetElement.DefaultInstance) return this;
+        PrepareBuilder();
+        if (other.HasS) {
+          S = other.S;
+        }
+        this.MergeUnknownFields(other.UnknownFields);
+        return this;
+      }
+      
+      public override Builder MergeFrom(pb::ICodedInputStream input) {
+        return MergeFrom(input, pb::ExtensionRegistry.Empty);
+      }
+      
+      public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
+        PrepareBuilder();
+        pb::UnknownFieldSet.Builder unknownFields = null;
+        uint tag;
+        string field_name;
+        while (input.ReadTag(out tag, out field_name)) {
+          if(tag == 0 && field_name != null) {
+            int field_ordinal = global::System.Array.BinarySearch(_aggregateMessageSetElementFieldNames, field_name, global::System.StringComparer.Ordinal);
+            if(field_ordinal >= 0)
+              tag = _aggregateMessageSetElementFieldTags[field_ordinal];
+            else {
+              if (unknownFields == null) {
+                unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
+              }
+              ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
+              continue;
+            }
+          }
+          switch (tag) {
+            case 0: {
+              throw pb::InvalidProtocolBufferException.InvalidTag();
+            }
+            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, field_name);
+              break;
+            }
+            case 10: {
+              result.hasS = input.ReadString(ref result.s_);
+              break;
+            }
+          }
+        }
+        
+        if (unknownFields != null) {
+          this.UnknownFields = unknownFields.Build();
+        }
+        return this;
+      }
+      
+      
+      public bool HasS {
+        get { return result.hasS; }
+      }
+      public string S {
+        get { return result.S; }
+        set { SetS(value); }
+      }
+      public Builder SetS(string value) {
+        pb::ThrowHelper.ThrowIfNull(value, "value");
+        PrepareBuilder();
+        result.hasS = true;
+        result.s_ = value;
+        return this;
+      }
+      public Builder ClearS() {
+        PrepareBuilder();
+        result.hasS = false;
+        result.s_ = "";
+        return this;
+      }
+    }
+    static AggregateMessageSetElement() {
+      object.ReferenceEquals(global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.Descriptor, null);
+    }
+  }
+  
+  [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+  [global::System.CodeDom.Compiler.GeneratedCodeAttribute("ProtoGen", "2.3.0.277")]
+  public sealed partial class Aggregate : pb::GeneratedMessage<Aggregate, Aggregate.Builder> {
+    private Aggregate() { }
+    private static readonly Aggregate defaultInstance = new Aggregate().MakeReadOnly();
+    private static readonly string[] _aggregateFieldNames = new string[] { "file", "i", "mset", "s", "sub" };
+    private static readonly uint[] _aggregateFieldTags = new uint[] { 34, 8, 42, 18, 26 };
+    public static Aggregate DefaultInstance {
+      get { return defaultInstance; }
+    }
+    
+    public override Aggregate DefaultInstanceForType {
+      get { return DefaultInstance; }
+    }
+    
+    protected override Aggregate ThisMessage {
+      get { return this; }
+    }
+    
+    public static pbd::MessageDescriptor Descriptor {
+      get { return global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.internal__static_protobuf_unittest_Aggregate__Descriptor; }
+    }
+    
+    protected override pb::FieldAccess.FieldAccessorTable<Aggregate, Aggregate.Builder> InternalFieldAccessors {
+      get { return global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.internal__static_protobuf_unittest_Aggregate__FieldAccessorTable; }
+    }
+    
+    public const int NestedFieldNumber = 15476903;
+    public static pb::GeneratedExtensionBase<global::Google.ProtocolBuffers.TestProtos.Aggregate> Nested;
+    public const int IFieldNumber = 1;
+    private bool hasI;
+    private int i_;
+    public bool HasI {
+      get { return hasI; }
+    }
+    public int I {
+      get { return i_; }
+    }
+    
+    public const int SFieldNumber = 2;
+    private bool hasS;
+    private string s_ = "";
+    public bool HasS {
+      get { return hasS; }
+    }
+    public string S {
+      get { return s_; }
+    }
+    
+    public const int SubFieldNumber = 3;
+    private bool hasSub;
+    private global::Google.ProtocolBuffers.TestProtos.Aggregate sub_;
+    public bool HasSub {
+      get { return hasSub; }
+    }
+    public global::Google.ProtocolBuffers.TestProtos.Aggregate Sub {
+      get { return sub_ ?? global::Google.ProtocolBuffers.TestProtos.Aggregate.DefaultInstance; }
+    }
+    
+    public const int FileFieldNumber = 4;
+    private bool hasFile;
+    private global::Google.ProtocolBuffers.DescriptorProtos.FileOptions file_;
+    public bool HasFile {
+      get { return hasFile; }
+    }
+    public global::Google.ProtocolBuffers.DescriptorProtos.FileOptions File {
+      get { return file_ ?? global::Google.ProtocolBuffers.DescriptorProtos.FileOptions.DefaultInstance; }
+    }
+    
+    public const int MsetFieldNumber = 5;
+    private bool hasMset;
+    private global::Google.ProtocolBuffers.TestProtos.AggregateMessageSet mset_;
+    public bool HasMset {
+      get { return hasMset; }
+    }
+    public global::Google.ProtocolBuffers.TestProtos.AggregateMessageSet Mset {
+      get { return mset_ ?? global::Google.ProtocolBuffers.TestProtos.AggregateMessageSet.DefaultInstance; }
+    }
+    
+    public override bool IsInitialized {
+      get {
+        if (HasSub) {
+          if (!Sub.IsInitialized) return false;
+        }
+        if (HasFile) {
+          if (!File.IsInitialized) return false;
+        }
+        return true;
+      }
+    }
+    
+    public override void WriteTo(pb::ICodedOutputStream output) {
+      int size = SerializedSize;
+      string[] field_names = _aggregateFieldNames;
+      if (hasI) {
+        output.WriteInt32(1, field_names[1], I);
+      }
+      if (hasS) {
+        output.WriteString(2, field_names[3], S);
+      }
+      if (hasSub) {
+        output.WriteMessage(3, field_names[4], Sub);
+      }
+      if (hasFile) {
+        output.WriteMessage(4, field_names[0], File);
+      }
+      if (hasMset) {
+        output.WriteMessage(5, field_names[2], Mset);
+      }
+      UnknownFields.WriteTo(output);
+    }
+    
+    private int memoizedSerializedSize = -1;
+    public override int SerializedSize {
+      get {
+        int size = memoizedSerializedSize;
+        if (size != -1) return size;
+        
+        size = 0;
+        if (hasI) {
+          size += pb::CodedOutputStream.ComputeInt32Size(1, I);
+        }
+        if (hasS) {
+          size += pb::CodedOutputStream.ComputeStringSize(2, S);
+        }
+        if (hasSub) {
+          size += pb::CodedOutputStream.ComputeMessageSize(3, Sub);
+        }
+        if (hasFile) {
+          size += pb::CodedOutputStream.ComputeMessageSize(4, File);
+        }
+        if (hasMset) {
+          size += pb::CodedOutputStream.ComputeMessageSize(5, Mset);
+        }
+        size += UnknownFields.SerializedSize;
+        memoizedSerializedSize = size;
+        return size;
+      }
+    }
+    
+    public static Aggregate ParseFrom(pb::ByteString data) {
+      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
+    }
+    public static Aggregate ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
+    }
+    public static Aggregate ParseFrom(byte[] data) {
+      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
+    }
+    public static Aggregate ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
+    }
+    public static Aggregate ParseFrom(global::System.IO.Stream input) {
+      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
+    }
+    public static Aggregate ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
+    }
+    public static Aggregate ParseDelimitedFrom(global::System.IO.Stream input) {
+      return CreateBuilder().MergeDelimitedFrom(input).BuildParsed();
+    }
+    public static Aggregate ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
+      return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed();
+    }
+    public static Aggregate ParseFrom(pb::ICodedInputStream input) {
+      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
+    }
+    public static Aggregate ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
+    }
+    private Aggregate MakeReadOnly() {
+      return this;
+    }
+    
+    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(Aggregate prototype) {
+      return new Builder(prototype);
+    }
+    
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("ProtoGen", "2.3.0.277")]
+    public sealed partial class Builder : pb::GeneratedBuilder<Aggregate, Builder> {
+      protected override Builder ThisBuilder {
+        get { return this; }
+      }
+      public Builder() {
+        result = DefaultInstance;
+        resultIsReadOnly = true;
+      }
+      internal Builder(Aggregate cloneFrom) {
+        result = cloneFrom;
+        resultIsReadOnly = true;
+      }
+      
+      private bool resultIsReadOnly;
+      private Aggregate result;
+      
+      private Aggregate PrepareBuilder() {
+        if (resultIsReadOnly) {
+          Aggregate original = result;
+          result = new Aggregate();
+          resultIsReadOnly = false;
+          MergeFrom(original);
+        }
+        return result;
+      }
+      
+      public override bool IsInitialized {
+        get { return result.IsInitialized; }
+      }
+      
+      protected override Aggregate MessageBeingBuilt {
+        get { return PrepareBuilder(); }
+      }
+      
+      public override Builder Clear() {
+        result = DefaultInstance;
+        resultIsReadOnly = true;
+        return this;
+      }
+      
+      public override Builder Clone() {
+        if (resultIsReadOnly) {
+          return new Builder(result);
+        } else {
+          return new Builder().MergeFrom(result);
+        }
+      }
+      
+      public override pbd::MessageDescriptor DescriptorForType {
+        get { return global::Google.ProtocolBuffers.TestProtos.Aggregate.Descriptor; }
+      }
+      
+      public override Aggregate DefaultInstanceForType {
+        get { return global::Google.ProtocolBuffers.TestProtos.Aggregate.DefaultInstance; }
+      }
+      
+      public override Aggregate BuildPartial() {
+        if (resultIsReadOnly) {
+          return result;
+        }
+        resultIsReadOnly = true;
+        return result.MakeReadOnly();
+      }
+      
+      public override Builder MergeFrom(pb::IMessage other) {
+        if (other is Aggregate) {
+          return MergeFrom((Aggregate) other);
+        } else {
+          base.MergeFrom(other);
+          return this;
+        }
+      }
+      
+      public override Builder MergeFrom(Aggregate other) {
+        if (other == global::Google.ProtocolBuffers.TestProtos.Aggregate.DefaultInstance) return this;
+        PrepareBuilder();
+        if (other.HasI) {
+          I = other.I;
+        }
+        if (other.HasS) {
+          S = other.S;
+        }
+        if (other.HasSub) {
+          MergeSub(other.Sub);
+        }
+        if (other.HasFile) {
+          MergeFile(other.File);
+        }
+        if (other.HasMset) {
+          MergeMset(other.Mset);
+        }
+        this.MergeUnknownFields(other.UnknownFields);
+        return this;
+      }
+      
+      public override Builder MergeFrom(pb::ICodedInputStream input) {
+        return MergeFrom(input, pb::ExtensionRegistry.Empty);
+      }
+      
+      public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
+        PrepareBuilder();
+        pb::UnknownFieldSet.Builder unknownFields = null;
+        uint tag;
+        string field_name;
+        while (input.ReadTag(out tag, out field_name)) {
+          if(tag == 0 && field_name != null) {
+            int field_ordinal = global::System.Array.BinarySearch(_aggregateFieldNames, field_name, global::System.StringComparer.Ordinal);
+            if(field_ordinal >= 0)
+              tag = _aggregateFieldTags[field_ordinal];
+            else {
+              if (unknownFields == null) {
+                unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
+              }
+              ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
+              continue;
+            }
+          }
+          switch (tag) {
+            case 0: {
+              throw pb::InvalidProtocolBufferException.InvalidTag();
+            }
+            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, field_name);
+              break;
+            }
+            case 8: {
+              result.hasI = input.ReadInt32(ref result.i_);
+              break;
+            }
+            case 18: {
+              result.hasS = input.ReadString(ref result.s_);
+              break;
+            }
+            case 26: {
+              global::Google.ProtocolBuffers.TestProtos.Aggregate.Builder subBuilder = global::Google.ProtocolBuffers.TestProtos.Aggregate.CreateBuilder();
+              if (result.hasSub) {
+                subBuilder.MergeFrom(Sub);
+              }
+              input.ReadMessage(subBuilder, extensionRegistry);
+              Sub = subBuilder.BuildPartial();
+              break;
+            }
+            case 34: {
+              global::Google.ProtocolBuffers.DescriptorProtos.FileOptions.Builder subBuilder = global::Google.ProtocolBuffers.DescriptorProtos.FileOptions.CreateBuilder();
+              if (result.hasFile) {
+                subBuilder.MergeFrom(File);
+              }
+              input.ReadMessage(subBuilder, extensionRegistry);
+              File = subBuilder.BuildPartial();
+              break;
+            }
+            case 42: {
+              global::Google.ProtocolBuffers.TestProtos.AggregateMessageSet.Builder subBuilder = global::Google.ProtocolBuffers.TestProtos.AggregateMessageSet.CreateBuilder();
+              if (result.hasMset) {
+                subBuilder.MergeFrom(Mset);
+              }
+              input.ReadMessage(subBuilder, extensionRegistry);
+              Mset = subBuilder.BuildPartial();
+              break;
+            }
+          }
+        }
+        
+        if (unknownFields != null) {
+          this.UnknownFields = unknownFields.Build();
+        }
+        return this;
+      }
+      
+      
+      public bool HasI {
+        get { return result.hasI; }
+      }
+      public int I {
+        get { return result.I; }
+        set { SetI(value); }
+      }
+      public Builder SetI(int value) {
+        PrepareBuilder();
+        result.hasI = true;
+        result.i_ = value;
+        return this;
+      }
+      public Builder ClearI() {
+        PrepareBuilder();
+        result.hasI = false;
+        result.i_ = 0;
+        return this;
+      }
+      
+      public bool HasS {
+        get { return result.hasS; }
+      }
+      public string S {
+        get { return result.S; }
+        set { SetS(value); }
+      }
+      public Builder SetS(string value) {
+        pb::ThrowHelper.ThrowIfNull(value, "value");
+        PrepareBuilder();
+        result.hasS = true;
+        result.s_ = value;
+        return this;
+      }
+      public Builder ClearS() {
+        PrepareBuilder();
+        result.hasS = false;
+        result.s_ = "";
+        return this;
+      }
+      
+      public bool HasSub {
+       get { return result.hasSub; }
+      }
+      public global::Google.ProtocolBuffers.TestProtos.Aggregate Sub {
+        get { return result.Sub; }
+        set { SetSub(value); }
+      }
+      public Builder SetSub(global::Google.ProtocolBuffers.TestProtos.Aggregate value) {
+        pb::ThrowHelper.ThrowIfNull(value, "value");
+        PrepareBuilder();
+        result.hasSub = true;
+        result.sub_ = value;
+        return this;
+      }
+      public Builder SetSub(global::Google.ProtocolBuffers.TestProtos.Aggregate.Builder builderForValue) {
+        pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue");
+        PrepareBuilder();
+        result.hasSub = true;
+        result.sub_ = builderForValue.Build();
+        return this;
+      }
+      public Builder MergeSub(global::Google.ProtocolBuffers.TestProtos.Aggregate value) {
+        pb::ThrowHelper.ThrowIfNull(value, "value");
+        PrepareBuilder();
+        if (result.hasSub &&
+            result.sub_ != global::Google.ProtocolBuffers.TestProtos.Aggregate.DefaultInstance) {
+            result.sub_ = global::Google.ProtocolBuffers.TestProtos.Aggregate.CreateBuilder(result.sub_).MergeFrom(value).BuildPartial();
+        } else {
+          result.sub_ = value;
+        }
+        result.hasSub = true;
+        return this;
+      }
+      public Builder ClearSub() {
+        PrepareBuilder();
+        result.hasSub = false;
+        result.sub_ = null;
+        return this;
+      }
+      
+      public bool HasFile {
+       get { return result.hasFile; }
+      }
+      public global::Google.ProtocolBuffers.DescriptorProtos.FileOptions File {
+        get { return result.File; }
+        set { SetFile(value); }
+      }
+      public Builder SetFile(global::Google.ProtocolBuffers.DescriptorProtos.FileOptions value) {
+        pb::ThrowHelper.ThrowIfNull(value, "value");
+        PrepareBuilder();
+        result.hasFile = true;
+        result.file_ = value;
+        return this;
+      }
+      public Builder SetFile(global::Google.ProtocolBuffers.DescriptorProtos.FileOptions.Builder builderForValue) {
+        pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue");
+        PrepareBuilder();
+        result.hasFile = true;
+        result.file_ = builderForValue.Build();
+        return this;
+      }
+      public Builder MergeFile(global::Google.ProtocolBuffers.DescriptorProtos.FileOptions value) {
+        pb::ThrowHelper.ThrowIfNull(value, "value");
+        PrepareBuilder();
+        if (result.hasFile &&
+            result.file_ != global::Google.ProtocolBuffers.DescriptorProtos.FileOptions.DefaultInstance) {
+            result.file_ = global::Google.ProtocolBuffers.DescriptorProtos.FileOptions.CreateBuilder(result.file_).MergeFrom(value).BuildPartial();
+        } else {
+          result.file_ = value;
+        }
+        result.hasFile = true;
+        return this;
+      }
+      public Builder ClearFile() {
+        PrepareBuilder();
+        result.hasFile = false;
+        result.file_ = null;
+        return this;
+      }
+      
+      public bool HasMset {
+       get { return result.hasMset; }
+      }
+      public global::Google.ProtocolBuffers.TestProtos.AggregateMessageSet Mset {
+        get { return result.Mset; }
+        set { SetMset(value); }
+      }
+      public Builder SetMset(global::Google.ProtocolBuffers.TestProtos.AggregateMessageSet value) {
+        pb::ThrowHelper.ThrowIfNull(value, "value");
+        PrepareBuilder();
+        result.hasMset = true;
+        result.mset_ = value;
+        return this;
+      }
+      public Builder SetMset(global::Google.ProtocolBuffers.TestProtos.AggregateMessageSet.Builder builderForValue) {
+        pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue");
+        PrepareBuilder();
+        result.hasMset = true;
+        result.mset_ = builderForValue.Build();
+        return this;
+      }
+      public Builder MergeMset(global::Google.ProtocolBuffers.TestProtos.AggregateMessageSet value) {
+        pb::ThrowHelper.ThrowIfNull(value, "value");
+        PrepareBuilder();
+        if (result.hasMset &&
+            result.mset_ != global::Google.ProtocolBuffers.TestProtos.AggregateMessageSet.DefaultInstance) {
+            result.mset_ = global::Google.ProtocolBuffers.TestProtos.AggregateMessageSet.CreateBuilder(result.mset_).MergeFrom(value).BuildPartial();
+        } else {
+          result.mset_ = value;
+        }
+        result.hasMset = true;
+        return this;
+      }
+      public Builder ClearMset() {
+        PrepareBuilder();
+        result.hasMset = false;
+        result.mset_ = null;
+        return this;
+      }
+    }
+    static Aggregate() {
+      object.ReferenceEquals(global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.Descriptor, null);
+    }
+  }
+  
+  [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+  [global::System.CodeDom.Compiler.GeneratedCodeAttribute("ProtoGen", "2.3.0.277")]
+  public sealed partial class AggregateMessage : pb::GeneratedMessage<AggregateMessage, AggregateMessage.Builder> {
+    private AggregateMessage() { }
+    private static readonly AggregateMessage defaultInstance = new AggregateMessage().MakeReadOnly();
+    private static readonly string[] _aggregateMessageFieldNames = new string[] { "fieldname" };
+    private static readonly uint[] _aggregateMessageFieldTags = new uint[] { 8 };
+    public static AggregateMessage DefaultInstance {
+      get { return defaultInstance; }
+    }
+    
+    public override AggregateMessage DefaultInstanceForType {
+      get { return DefaultInstance; }
+    }
+    
+    protected override AggregateMessage ThisMessage {
+      get { return this; }
+    }
+    
+    public static pbd::MessageDescriptor Descriptor {
+      get { return global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.internal__static_protobuf_unittest_AggregateMessage__Descriptor; }
+    }
+    
+    protected override pb::FieldAccess.FieldAccessorTable<AggregateMessage, AggregateMessage.Builder> InternalFieldAccessors {
+      get { return global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.internal__static_protobuf_unittest_AggregateMessage__FieldAccessorTable; }
+    }
+    
+    public const int FieldnameFieldNumber = 1;
+    private bool hasFieldname;
+    private int fieldname_;
+    public bool HasFieldname {
+      get { return hasFieldname; }
+    }
+    public int Fieldname {
+      get { return fieldname_; }
+    }
+    
+    public override bool IsInitialized {
+      get {
+        return true;
+      }
+    }
+    
+    public override void WriteTo(pb::ICodedOutputStream output) {
+      int size = SerializedSize;
+      string[] field_names = _aggregateMessageFieldNames;
+      if (hasFieldname) {
+        output.WriteInt32(1, field_names[0], Fieldname);
+      }
+      UnknownFields.WriteTo(output);
+    }
+    
+    private int memoizedSerializedSize = -1;
+    public override int SerializedSize {
+      get {
+        int size = memoizedSerializedSize;
+        if (size != -1) return size;
+        
+        size = 0;
+        if (hasFieldname) {
+          size += pb::CodedOutputStream.ComputeInt32Size(1, Fieldname);
+        }
+        size += UnknownFields.SerializedSize;
+        memoizedSerializedSize = size;
+        return size;
+      }
+    }
+    
+    public static AggregateMessage ParseFrom(pb::ByteString data) {
+      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
+    }
+    public static AggregateMessage ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
+    }
+    public static AggregateMessage ParseFrom(byte[] data) {
+      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
+    }
+    public static AggregateMessage ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
+    }
+    public static AggregateMessage ParseFrom(global::System.IO.Stream input) {
+      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
+    }
+    public static AggregateMessage ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
+    }
+    public static AggregateMessage ParseDelimitedFrom(global::System.IO.Stream input) {
+      return CreateBuilder().MergeDelimitedFrom(input).BuildParsed();
+    }
+    public static AggregateMessage ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
+      return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed();
+    }
+    public static AggregateMessage ParseFrom(pb::ICodedInputStream input) {
+      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
+    }
+    public static AggregateMessage ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
+    }
+    private AggregateMessage MakeReadOnly() {
+      return this;
+    }
+    
+    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(AggregateMessage prototype) {
+      return new Builder(prototype);
+    }
+    
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("ProtoGen", "2.3.0.277")]
+    public sealed partial class Builder : pb::GeneratedBuilder<AggregateMessage, Builder> {
+      protected override Builder ThisBuilder {
+        get { return this; }
+      }
+      public Builder() {
+        result = DefaultInstance;
+        resultIsReadOnly = true;
+      }
+      internal Builder(AggregateMessage cloneFrom) {
+        result = cloneFrom;
+        resultIsReadOnly = true;
+      }
+      
+      private bool resultIsReadOnly;
+      private AggregateMessage result;
+      
+      private AggregateMessage PrepareBuilder() {
+        if (resultIsReadOnly) {
+          AggregateMessage original = result;
+          result = new AggregateMessage();
+          resultIsReadOnly = false;
+          MergeFrom(original);
+        }
+        return result;
+      }
+      
+      public override bool IsInitialized {
+        get { return result.IsInitialized; }
+      }
+      
+      protected override AggregateMessage MessageBeingBuilt {
+        get { return PrepareBuilder(); }
+      }
+      
+      public override Builder Clear() {
+        result = DefaultInstance;
+        resultIsReadOnly = true;
+        return this;
+      }
+      
+      public override Builder Clone() {
+        if (resultIsReadOnly) {
+          return new Builder(result);
+        } else {
+          return new Builder().MergeFrom(result);
+        }
+      }
+      
+      public override pbd::MessageDescriptor DescriptorForType {
+        get { return global::Google.ProtocolBuffers.TestProtos.AggregateMessage.Descriptor; }
+      }
+      
+      public override AggregateMessage DefaultInstanceForType {
+        get { return global::Google.ProtocolBuffers.TestProtos.AggregateMessage.DefaultInstance; }
+      }
+      
+      public override AggregateMessage BuildPartial() {
+        if (resultIsReadOnly) {
+          return result;
+        }
+        resultIsReadOnly = true;
+        return result.MakeReadOnly();
+      }
+      
+      public override Builder MergeFrom(pb::IMessage other) {
+        if (other is AggregateMessage) {
+          return MergeFrom((AggregateMessage) other);
+        } else {
+          base.MergeFrom(other);
+          return this;
+        }
+      }
+      
+      public override Builder MergeFrom(AggregateMessage other) {
+        if (other == global::Google.ProtocolBuffers.TestProtos.AggregateMessage.DefaultInstance) return this;
+        PrepareBuilder();
+        if (other.HasFieldname) {
+          Fieldname = other.Fieldname;
+        }
+        this.MergeUnknownFields(other.UnknownFields);
+        return this;
+      }
+      
+      public override Builder MergeFrom(pb::ICodedInputStream input) {
+        return MergeFrom(input, pb::ExtensionRegistry.Empty);
+      }
+      
+      public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
+        PrepareBuilder();
+        pb::UnknownFieldSet.Builder unknownFields = null;
+        uint tag;
+        string field_name;
+        while (input.ReadTag(out tag, out field_name)) {
+          if(tag == 0 && field_name != null) {
+            int field_ordinal = global::System.Array.BinarySearch(_aggregateMessageFieldNames, field_name, global::System.StringComparer.Ordinal);
+            if(field_ordinal >= 0)
+              tag = _aggregateMessageFieldTags[field_ordinal];
+            else {
+              if (unknownFields == null) {
+                unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
+              }
+              ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
+              continue;
+            }
+          }
+          switch (tag) {
+            case 0: {
+              throw pb::InvalidProtocolBufferException.InvalidTag();
+            }
+            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, field_name);
+              break;
+            }
+            case 8: {
+              result.hasFieldname = input.ReadInt32(ref result.fieldname_);
+              break;
+            }
+          }
+        }
+        
+        if (unknownFields != null) {
+          this.UnknownFields = unknownFields.Build();
+        }
+        return this;
+      }
+      
+      
+      public bool HasFieldname {
+        get { return result.hasFieldname; }
+      }
+      public int Fieldname {
+        get { return result.Fieldname; }
+        set { SetFieldname(value); }
+      }
+      public Builder SetFieldname(int value) {
+        PrepareBuilder();
+        result.hasFieldname = true;
+        result.fieldname_ = value;
+        return this;
+      }
+      public Builder ClearFieldname() {
+        PrepareBuilder();
+        result.hasFieldname = false;
+        result.fieldname_ = 0;
+        return this;
+      }
+    }
+    static AggregateMessage() {
+      object.ReferenceEquals(global::Google.ProtocolBuffers.TestProtos.UnitTestCustomOptionsProtoFile.Descriptor, null);
+    }
+  }
+  
+  #endregion
+  
+  #region Services
+  /*
+  * Service generation is now disabled by default, use the following option to enable:
+  * option (google.protobuf.csharp_file_options).service_generator_type = GENERIC;
+  */
   /*
   * Service generation is now disabled by default, use the following option to enable:
   * option (google.protobuf.csharp_file_options).service_generator_type = GENERIC;

src/ProtocolBuffers.Test/TestProtos/UnitTestExtrasProtoFile.cs

@@ -0,0 +1,403 @@
+// Generated by ProtoGen, Version=2.3.0.277, Culture=neutral, PublicKeyToken=17b3b1f090c3ea48.  DO NOT EDIT!
+#pragma warning disable 1591, 0612
+#region Designer generated code
+
+using pb = global::Google.ProtocolBuffers;
+using pbc = global::Google.ProtocolBuffers.Collections;
+using pbd = global::Google.ProtocolBuffers.Descriptors;
+using scg = global::System.Collections.Generic;
+namespace Google.ProtocolBuffers.TestProtos {
+  
+  [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+  [global::System.CodeDom.Compiler.GeneratedCodeAttribute("ProtoGen", "2.3.0.277")]
+  public static partial class UnitTestExtrasProtoFile {
+  
+    #region Extension registration
+    public static void RegisterAllExtensions(pb::ExtensionRegistry registry) {
+      registry.Add(global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasProtoFile.UnpackedInt32Extension);
+      registry.Add(global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasProtoFile.UnpackedInt64Extension);
+      registry.Add(global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasProtoFile.UnpackedUint32Extension);
+      registry.Add(global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasProtoFile.UnpackedUint64Extension);
+      registry.Add(global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasProtoFile.UnpackedSint32Extension);
+      registry.Add(global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasProtoFile.UnpackedSint64Extension);
+      registry.Add(global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasProtoFile.UnpackedFixed32Extension);
+      registry.Add(global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasProtoFile.UnpackedFixed64Extension);
+      registry.Add(global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasProtoFile.UnpackedSfixed32Extension);
+      registry.Add(global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasProtoFile.UnpackedSfixed64Extension);
+      registry.Add(global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasProtoFile.UnpackedFloatExtension);
+      registry.Add(global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasProtoFile.UnpackedDoubleExtension);
+      registry.Add(global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasProtoFile.UnpackedBoolExtension);
+      registry.Add(global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasProtoFile.UnpackedEnumExtension);
+    }
+    #endregion
+    #region Extensions
+    public const int UnpackedInt32ExtensionFieldNumber = 90;
+    public static pb::GeneratedExtensionBase<scg::IList<int>> UnpackedInt32Extension;
+    public const int UnpackedInt64ExtensionFieldNumber = 91;
+    public static pb::GeneratedExtensionBase<scg::IList<long>> UnpackedInt64Extension;
+    public const int UnpackedUint32ExtensionFieldNumber = 92;
+    [global::System.CLSCompliant(false)]
+    public static pb::GeneratedExtensionBase<scg::IList<uint>> UnpackedUint32Extension;
+    public const int UnpackedUint64ExtensionFieldNumber = 93;
+    [global::System.CLSCompliant(false)]
+    public static pb::GeneratedExtensionBase<scg::IList<ulong>> UnpackedUint64Extension;
+    public const int UnpackedSint32ExtensionFieldNumber = 94;
+    public static pb::GeneratedExtensionBase<scg::IList<int>> UnpackedSint32Extension;
+    public const int UnpackedSint64ExtensionFieldNumber = 95;
+    public static pb::GeneratedExtensionBase<scg::IList<long>> UnpackedSint64Extension;
+    public const int UnpackedFixed32ExtensionFieldNumber = 96;
+    [global::System.CLSCompliant(false)]
+    public static pb::GeneratedExtensionBase<scg::IList<uint>> UnpackedFixed32Extension;
+    public const int UnpackedFixed64ExtensionFieldNumber = 97;
+    [global::System.CLSCompliant(false)]
+    public static pb::GeneratedExtensionBase<scg::IList<ulong>> UnpackedFixed64Extension;
+    public const int UnpackedSfixed32ExtensionFieldNumber = 98;
+    public static pb::GeneratedExtensionBase<scg::IList<int>> UnpackedSfixed32Extension;
+    public const int UnpackedSfixed64ExtensionFieldNumber = 99;
+    public static pb::GeneratedExtensionBase<scg::IList<long>> UnpackedSfixed64Extension;
+    public const int UnpackedFloatExtensionFieldNumber = 100;
+    public static pb::GeneratedExtensionBase<scg::IList<float>> UnpackedFloatExtension;
+    public const int UnpackedDoubleExtensionFieldNumber = 101;
+    public static pb::GeneratedExtensionBase<scg::IList<double>> UnpackedDoubleExtension;
+    public const int UnpackedBoolExtensionFieldNumber = 102;
+    public static pb::GeneratedExtensionBase<scg::IList<bool>> UnpackedBoolExtension;
+    public const int UnpackedEnumExtensionFieldNumber = 103;
+    public static pb::GeneratedExtensionBase<scg::IList<global::Google.ProtocolBuffers.TestProtos.UnpackedExtensionsForeignEnum>> UnpackedEnumExtension;
+    #endregion
+    
+    #region Static variables
+    internal static pbd::MessageDescriptor internal__static_protobuf_unittest_extra_TestUnpackedExtensions__Descriptor;
+    internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.TestUnpackedExtensions, global::Google.ProtocolBuffers.TestProtos.TestUnpackedExtensions.Builder> internal__static_protobuf_unittest_extra_TestUnpackedExtensions__FieldAccessorTable;
+    #endregion
+    #region Descriptor
+    public static pbd::FileDescriptor Descriptor {
+      get { return descriptor; }
+    }
+    private static pbd::FileDescriptor descriptor;
+    
+    static UnitTestExtrasProtoFile() {
+      byte[] descriptorData = global::System.Convert.FromBase64String(
+          "ChxleHRlc3QvdW5pdHRlc3RfZXh0cmFzLnByb3RvEhdwcm90b2J1Zl91bml0" + 
+          "dGVzdF9leHRyYRokZ29vZ2xlL3Byb3RvYnVmL2NzaGFycF9vcHRpb25zLnBy" + 
+          "b3RvIiIKFlRlc3RVbnBhY2tlZEV4dGVuc2lvbnMqCAgBEICAgIACKlIKHVVu" + 
+          "cGFja2VkRXh0ZW5zaW9uc0ZvcmVpZ25FbnVtEg8KC0ZPUkVJR05fRk9PEAQS" + 
+          "DwoLRk9SRUlHTl9CQVIQBRIPCgtGT1JFSUdOX0JBWhAGOlEKGHVucGFja2Vk" + 
+          "X2ludDMyX2V4dGVuc2lvbhIvLnByb3RvYnVmX3VuaXR0ZXN0X2V4dHJhLlRl" + 
+          "c3RVbnBhY2tlZEV4dGVuc2lvbnMYWiADKAU6UQoYdW5wYWNrZWRfaW50NjRf" + 
+          "ZXh0ZW5zaW9uEi8ucHJvdG9idWZfdW5pdHRlc3RfZXh0cmEuVGVzdFVucGFj" + 
+          "a2VkRXh0ZW5zaW9ucxhbIAMoAzpSChl1bnBhY2tlZF91aW50MzJfZXh0ZW5z" + 
+          "aW9uEi8ucHJvdG9idWZfdW5pdHRlc3RfZXh0cmEuVGVzdFVucGFja2VkRXh0" + 
+          "ZW5zaW9ucxhcIAMoDTpSChl1bnBhY2tlZF91aW50NjRfZXh0ZW5zaW9uEi8u" + 
+          "cHJvdG9idWZfdW5pdHRlc3RfZXh0cmEuVGVzdFVucGFja2VkRXh0ZW5zaW9u" + 
+          "cxhdIAMoBDpSChl1bnBhY2tlZF9zaW50MzJfZXh0ZW5zaW9uEi8ucHJvdG9i" + 
+          "dWZfdW5pdHRlc3RfZXh0cmEuVGVzdFVucGFja2VkRXh0ZW5zaW9ucxheIAMo" + 
+          "ETpSChl1bnBhY2tlZF9zaW50NjRfZXh0ZW5zaW9uEi8ucHJvdG9idWZfdW5p" + 
+          "dHRlc3RfZXh0cmEuVGVzdFVucGFja2VkRXh0ZW5zaW9ucxhfIAMoEjpTChp1" + 
+          "bnBhY2tlZF9maXhlZDMyX2V4dGVuc2lvbhIvLnByb3RvYnVmX3VuaXR0ZXN0" + 
+          "X2V4dHJhLlRlc3RVbnBhY2tlZEV4dGVuc2lvbnMYYCADKAc6UwoadW5wYWNr" + 
+          "ZWRfZml4ZWQ2NF9leHRlbnNpb24SLy5wcm90b2J1Zl91bml0dGVzdF9leHRy" + 
+          "YS5UZXN0VW5wYWNrZWRFeHRlbnNpb25zGGEgAygGOlQKG3VucGFja2VkX3Nm" + 
+          "aXhlZDMyX2V4dGVuc2lvbhIvLnByb3RvYnVmX3VuaXR0ZXN0X2V4dHJhLlRl" + 
+          "c3RVbnBhY2tlZEV4dGVuc2lvbnMYYiADKA86VAobdW5wYWNrZWRfc2ZpeGVk" + 
+          "NjRfZXh0ZW5zaW9uEi8ucHJvdG9idWZfdW5pdHRlc3RfZXh0cmEuVGVzdFVu" + 
+          "cGFja2VkRXh0ZW5zaW9ucxhjIAMoEDpRChh1bnBhY2tlZF9mbG9hdF9leHRl" + 
+          "bnNpb24SLy5wcm90b2J1Zl91bml0dGVzdF9leHRyYS5UZXN0VW5wYWNrZWRF" + 
+          "eHRlbnNpb25zGGQgAygCOlIKGXVucGFja2VkX2RvdWJsZV9leHRlbnNpb24S" + 
+          "Ly5wcm90b2J1Zl91bml0dGVzdF9leHRyYS5UZXN0VW5wYWNrZWRFeHRlbnNp" + 
+          "b25zGGUgAygBOlAKF3VucGFja2VkX2Jvb2xfZXh0ZW5zaW9uEi8ucHJvdG9i" + 
+          "dWZfdW5pdHRlc3RfZXh0cmEuVGVzdFVucGFja2VkRXh0ZW5zaW9ucxhmIAMo" + 
+          "CDqIAQoXdW5wYWNrZWRfZW51bV9leHRlbnNpb24SLy5wcm90b2J1Zl91bml0" + 
+          "dGVzdF9leHRyYS5UZXN0VW5wYWNrZWRFeHRlbnNpb25zGGcgAygOMjYucHJv" + 
+          "dG9idWZfdW5pdHRlc3RfZXh0cmEuVW5wYWNrZWRFeHRlbnNpb25zRm9yZWln" + 
+          "bkVudW1CVgoTY29tLmdvb2dsZS5wcm90b2J1ZsI+PgohR29vZ2xlLlByb3Rv" + 
+          "Y29sQnVmZmVycy5UZXN0UHJvdG9zEhdVbml0VGVzdEV4dHJhc1Byb3RvRmls" + 
+          "ZUgB");
+      pbd::FileDescriptor.InternalDescriptorAssigner assigner = delegate(pbd::FileDescriptor root) {
+        descriptor = root;
+        internal__static_protobuf_unittest_extra_TestUnpackedExtensions__Descriptor = Descriptor.MessageTypes[0];
+        internal__static_protobuf_unittest_extra_TestUnpackedExtensions__FieldAccessorTable = 
+            new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.TestUnpackedExtensions, global::Google.ProtocolBuffers.TestProtos.TestUnpackedExtensions.Builder>(internal__static_protobuf_unittest_extra_TestUnpackedExtensions__Descriptor,
+                new string[] { });
+        global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasProtoFile.UnpackedInt32Extension = pb::GeneratedRepeatExtension<int>.CreateInstance(global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasProtoFile.Descriptor.Extensions[0]);
+        global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasProtoFile.UnpackedInt64Extension = pb::GeneratedRepeatExtension<long>.CreateInstance(global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasProtoFile.Descriptor.Extensions[1]);
+        global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasProtoFile.UnpackedUint32Extension = pb::GeneratedRepeatExtension<uint>.CreateInstance(global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasProtoFile.Descriptor.Extensions[2]);
+        global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasProtoFile.UnpackedUint64Extension = pb::GeneratedRepeatExtension<ulong>.CreateInstance(global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasProtoFile.Descriptor.Extensions[3]);
+        global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasProtoFile.UnpackedSint32Extension = pb::GeneratedRepeatExtension<int>.CreateInstance(global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasProtoFile.Descriptor.Extensions[4]);
+        global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasProtoFile.UnpackedSint64Extension = pb::GeneratedRepeatExtension<long>.CreateInstance(global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasProtoFile.Descriptor.Extensions[5]);
+        global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasProtoFile.UnpackedFixed32Extension = pb::GeneratedRepeatExtension<uint>.CreateInstance(global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasProtoFile.Descriptor.Extensions[6]);
+        global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasProtoFile.UnpackedFixed64Extension = pb::GeneratedRepeatExtension<ulong>.CreateInstance(global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasProtoFile.Descriptor.Extensions[7]);
+        global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasProtoFile.UnpackedSfixed32Extension = pb::GeneratedRepeatExtension<int>.CreateInstance(global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasProtoFile.Descriptor.Extensions[8]);
+        global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasProtoFile.UnpackedSfixed64Extension = pb::GeneratedRepeatExtension<long>.CreateInstance(global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasProtoFile.Descriptor.Extensions[9]);
+        global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasProtoFile.UnpackedFloatExtension = pb::GeneratedRepeatExtension<float>.CreateInstance(global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasProtoFile.Descriptor.Extensions[10]);
+        global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasProtoFile.UnpackedDoubleExtension = pb::GeneratedRepeatExtension<double>.CreateInstance(global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasProtoFile.Descriptor.Extensions[11]);
+        global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasProtoFile.UnpackedBoolExtension = pb::GeneratedRepeatExtension<bool>.CreateInstance(global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasProtoFile.Descriptor.Extensions[12]);
+        global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasProtoFile.UnpackedEnumExtension = pb::GeneratedRepeatExtension<global::Google.ProtocolBuffers.TestProtos.UnpackedExtensionsForeignEnum>.CreateInstance(global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasProtoFile.Descriptor.Extensions[13]);
+        pb::ExtensionRegistry registry = pb::ExtensionRegistry.CreateInstance();
+        RegisterAllExtensions(registry);
+        global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.RegisterAllExtensions(registry);
+        return registry;
+      };
+      pbd::FileDescriptor.InternalBuildGeneratedFileFrom(descriptorData,
+          new pbd::FileDescriptor[] {
+          global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.Descriptor, 
+          }, assigner);
+    }
+    #endregion
+    
+  }
+  #region Enums
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+  [global::System.CodeDom.Compiler.GeneratedCodeAttribute("ProtoGen", "2.3.0.277")]
+  public enum UnpackedExtensionsForeignEnum {
+    FOREIGN_FOO = 4,
+    FOREIGN_BAR = 5,
+    FOREIGN_BAZ = 6,
+  }
+  
+  #endregion
+  
+  #region Messages
+  [global::System.SerializableAttribute()]
+  [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+  [global::System.CodeDom.Compiler.GeneratedCodeAttribute("ProtoGen", "2.3.0.277")]
+  public sealed partial class TestUnpackedExtensions : pb::ExtendableMessage<TestUnpackedExtensions, TestUnpackedExtensions.Builder> {
+    private TestUnpackedExtensions() { }
+    private static readonly TestUnpackedExtensions defaultInstance = new TestUnpackedExtensions().MakeReadOnly();
+    private static readonly string[] _testUnpackedExtensionsFieldNames = new string[] {  };
+    private static readonly uint[] _testUnpackedExtensionsFieldTags = new uint[] {  };
+    public static TestUnpackedExtensions DefaultInstance {
+      get { return defaultInstance; }
+    }
+    
+    public override TestUnpackedExtensions DefaultInstanceForType {
+      get { return DefaultInstance; }
+    }
+    
+    protected override TestUnpackedExtensions ThisMessage {
+      get { return this; }
+    }
+    
+    public static pbd::MessageDescriptor Descriptor {
+      get { return global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasProtoFile.internal__static_protobuf_unittest_extra_TestUnpackedExtensions__Descriptor; }
+    }
+    
+    protected override pb::FieldAccess.FieldAccessorTable<TestUnpackedExtensions, TestUnpackedExtensions.Builder> InternalFieldAccessors {
+      get { return global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasProtoFile.internal__static_protobuf_unittest_extra_TestUnpackedExtensions__FieldAccessorTable; }
+    }
+    
+    public override bool IsInitialized {
+      get {
+        if (!ExtensionsAreInitialized) return false;
+        return true;
+      }
+    }
+    
+    public override void WriteTo(pb::ICodedOutputStream output) {
+      int size = SerializedSize;
+      string[] field_names = _testUnpackedExtensionsFieldNames;
+      pb::ExtendableMessage<TestUnpackedExtensions, TestUnpackedExtensions.Builder>.ExtensionWriter extensionWriter = CreateExtensionWriter(this);
+      extensionWriter.WriteUntil(536870912, output);
+      UnknownFields.WriteTo(output);
+    }
+    
+    private int memoizedSerializedSize = -1;
+    public override int SerializedSize {
+      get {
+        int size = memoizedSerializedSize;
+        if (size != -1) return size;
+        
+        size = 0;
+        size += ExtensionsSerializedSize;
+        size += UnknownFields.SerializedSize;
+        memoizedSerializedSize = size;
+        return size;
+      }
+    }
+    
+    public static TestUnpackedExtensions ParseFrom(pb::ByteString data) {
+      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
+    }
+    public static TestUnpackedExtensions ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
+    }
+    public static TestUnpackedExtensions ParseFrom(byte[] data) {
+      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
+    }
+    public static TestUnpackedExtensions ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
+    }
+    public static TestUnpackedExtensions ParseFrom(global::System.IO.Stream input) {
+      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
+    }
+    public static TestUnpackedExtensions ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
+    }
+    public static TestUnpackedExtensions ParseDelimitedFrom(global::System.IO.Stream input) {
+      return CreateBuilder().MergeDelimitedFrom(input).BuildParsed();
+    }
+    public static TestUnpackedExtensions ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
+      return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed();
+    }
+    public static TestUnpackedExtensions ParseFrom(pb::ICodedInputStream input) {
+      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
+    }
+    public static TestUnpackedExtensions ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
+    }
+    private TestUnpackedExtensions MakeReadOnly() {
+      return this;
+    }
+    
+    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(TestUnpackedExtensions prototype) {
+      return new Builder(prototype);
+    }
+    
+    [global::System.SerializableAttribute()]
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("ProtoGen", "2.3.0.277")]
+    public sealed partial class Builder : pb::ExtendableBuilder<TestUnpackedExtensions, Builder> {
+      protected override Builder ThisBuilder {
+        get { return this; }
+      }
+      public Builder() {
+        result = DefaultInstance;
+        resultIsReadOnly = true;
+      }
+      internal Builder(TestUnpackedExtensions cloneFrom) {
+        result = cloneFrom;
+        resultIsReadOnly = true;
+      }
+      
+      private bool resultIsReadOnly;
+      private TestUnpackedExtensions result;
+      
+      private TestUnpackedExtensions PrepareBuilder() {
+        if (resultIsReadOnly) {
+          TestUnpackedExtensions original = result;
+          result = new TestUnpackedExtensions();
+          resultIsReadOnly = false;
+          MergeFrom(original);
+        }
+        return result;
+      }
+      
+      public override bool IsInitialized {
+        get { return result.IsInitialized; }
+      }
+      
+      protected override TestUnpackedExtensions MessageBeingBuilt {
+        get { return PrepareBuilder(); }
+      }
+      
+      public override Builder Clear() {
+        result = DefaultInstance;
+        resultIsReadOnly = true;
+        return this;
+      }
+      
+      public override Builder Clone() {
+        if (resultIsReadOnly) {
+          return new Builder(result);
+        } else {
+          return new Builder().MergeFrom(result);
+        }
+      }
+      
+      public override pbd::MessageDescriptor DescriptorForType {
+        get { return global::Google.ProtocolBuffers.TestProtos.TestUnpackedExtensions.Descriptor; }
+      }
+      
+      public override TestUnpackedExtensions DefaultInstanceForType {
+        get { return global::Google.ProtocolBuffers.TestProtos.TestUnpackedExtensions.DefaultInstance; }
+      }
+      
+      public override TestUnpackedExtensions BuildPartial() {
+        if (resultIsReadOnly) {
+          return result;
+        }
+        resultIsReadOnly = true;
+        return result.MakeReadOnly();
+      }
+      
+      public override Builder MergeFrom(pb::IMessage other) {
+        if (other is TestUnpackedExtensions) {
+          return MergeFrom((TestUnpackedExtensions) other);
+        } else {
+          base.MergeFrom(other);
+          return this;
+        }
+      }
+      
+      public override Builder MergeFrom(TestUnpackedExtensions other) {
+        if (other == global::Google.ProtocolBuffers.TestProtos.TestUnpackedExtensions.DefaultInstance) return this;
+        PrepareBuilder();
+          this.MergeExtensionFields(other);
+        this.MergeUnknownFields(other.UnknownFields);
+        return this;
+      }
+      
+      public override Builder MergeFrom(pb::ICodedInputStream input) {
+        return MergeFrom(input, pb::ExtensionRegistry.Empty);
+      }
+      
+      public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
+        PrepareBuilder();
+        pb::UnknownFieldSet.Builder unknownFields = null;
+        uint tag;
+        string field_name;
+        while (input.ReadTag(out tag, out field_name)) {
+          if(tag == 0 && field_name != null) {
+            int field_ordinal = global::System.Array.BinarySearch(_testUnpackedExtensionsFieldNames, field_name, global::System.StringComparer.Ordinal);
+            if(field_ordinal >= 0)
+              tag = _testUnpackedExtensionsFieldTags[field_ordinal];
+            else {
+              if (unknownFields == null) {
+                unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
+              }
+              ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
+              continue;
+            }
+          }
+          switch (tag) {
+            case 0: {
+              throw pb::InvalidProtocolBufferException.InvalidTag();
+            }
+            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, field_name);
+              break;
+            }
+          }
+        }
+        
+        if (unknownFields != null) {
+          this.UnknownFields = unknownFields.Build();
+        }
+        return this;
+      }
+      
+    }
+    static TestUnpackedExtensions() {
+      object.ReferenceEquals(global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasProtoFile.Descriptor, null);
+    }
+  }
+  
+  #endregion
+  
+}
+
+#endregion Designer generated code

src/ProtocolBuffers.Test/TestProtos/UnitTestNoGenericServicesProtoFile.cs

@@ -43,10 +43,10 @@ namespace Google.ProtocolBuffers.TestProtos.NoGenericService {
           "b3RvYnVmLm5vX2dlbmVyaWNfc2VydmljZXNfdGVzdC5UZXN0TWVzc2FnZRo1" + 
           "Lmdvb2dsZS5wcm90b2J1Zi5ub19nZW5lcmljX3NlcnZpY2VzX3Rlc3QuVGVz" + 
           "dE1lc3NhZ2U6TgoOdGVzdF9leHRlbnNpb24SNS5nb29nbGUucHJvdG9idWYu" + 
-          "bm9fZ2VuZXJpY19zZXJ2aWNlc190ZXN0LlRlc3RNZXNzYWdlGOgHIAEoBUJk" + 
-          "gAEAiAEAkAEAwj5YCjJHb29nbGUuUHJvdG9jb2xCdWZmZXJzLlRlc3RQcm90" + 
-          "b3MuTm9HZW5lcmljU2VydmljZRIiVW5pdFRlc3ROb0dlbmVyaWNTZXJ2aWNl" + 
-          "c1Byb3RvRmlsZQ==");
+          "bm9fZ2VuZXJpY19zZXJ2aWNlc190ZXN0LlRlc3RNZXNzYWdlGOgHIAEoBUJb" + 
+          "wj5YCjJHb29nbGUuUHJvdG9jb2xCdWZmZXJzLlRlc3RQcm90b3MuTm9HZW5l" + 
+          "cmljU2VydmljZRIiVW5pdFRlc3ROb0dlbmVyaWNTZXJ2aWNlc1Byb3RvRmls" + 
+          "ZQ==");
       pbd::FileDescriptor.InternalDescriptorAssigner assigner = delegate(pbd::FileDescriptor root) {
         descriptor = root;
         internal__static_google_protobuf_no_generic_services_test_TestMessage__Descriptor = Descriptor.MessageTypes[0];

src/ProtocolBuffersLite.Test/TestProtos/UnitTestExtrasLiteProtoFile.cs

@@ -16,11 +16,57 @@ namespace Google.ProtocolBuffers.TestProtos {
     #region Extension registration
     public static void RegisterAllExtensions(pb::ExtensionRegistry registry) {
       registry.Add(global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasLiteProtoFile.EmployeeIdLite);
+      registry.Add(global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasLiteProtoFile.UnpackedInt32ExtensionLite);
+      registry.Add(global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasLiteProtoFile.UnpackedInt64ExtensionLite);
+      registry.Add(global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasLiteProtoFile.UnpackedUint32ExtensionLite);
+      registry.Add(global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasLiteProtoFile.UnpackedUint64ExtensionLite);
+      registry.Add(global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasLiteProtoFile.UnpackedSint32ExtensionLite);
+      registry.Add(global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasLiteProtoFile.UnpackedSint64ExtensionLite);
+      registry.Add(global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasLiteProtoFile.UnpackedFixed32ExtensionLite);
+      registry.Add(global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasLiteProtoFile.UnpackedFixed64ExtensionLite);
+      registry.Add(global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasLiteProtoFile.UnpackedSfixed32ExtensionLite);
+      registry.Add(global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasLiteProtoFile.UnpackedSfixed64ExtensionLite);
+      registry.Add(global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasLiteProtoFile.UnpackedFloatExtensionLite);
+      registry.Add(global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasLiteProtoFile.UnpackedDoubleExtensionLite);
+      registry.Add(global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasLiteProtoFile.UnpackedBoolExtensionLite);
+      registry.Add(global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasLiteProtoFile.UnpackedEnumExtensionLite);
     }
     #endregion
     #region Extensions
     public const int EmployeeIdLiteFieldNumber = 126;
     public static pb::GeneratedExtensionLite<global::Google.ProtocolBuffers.TestProtos.TestInteropPersonLite, global::Google.ProtocolBuffers.TestProtos.TestInteropEmployeeIdLite> EmployeeIdLite;
+    public const int UnpackedInt32ExtensionLiteFieldNumber = 90;
+    public static pb::GeneratedRepeatExtensionLite<global::Google.ProtocolBuffers.TestProtos.TestUnpackedExtensionsLite, int> UnpackedInt32ExtensionLite;
+    public const int UnpackedInt64ExtensionLiteFieldNumber = 91;
+    public static pb::GeneratedRepeatExtensionLite<global::Google.ProtocolBuffers.TestProtos.TestUnpackedExtensionsLite, long> UnpackedInt64ExtensionLite;
+    public const int UnpackedUint32ExtensionLiteFieldNumber = 92;
+    [global::System.CLSCompliant(false)]
+    public static pb::GeneratedRepeatExtensionLite<global::Google.ProtocolBuffers.TestProtos.TestUnpackedExtensionsLite, uint> UnpackedUint32ExtensionLite;
+    public const int UnpackedUint64ExtensionLiteFieldNumber = 93;
+    [global::System.CLSCompliant(false)]
+    public static pb::GeneratedRepeatExtensionLite<global::Google.ProtocolBuffers.TestProtos.TestUnpackedExtensionsLite, ulong> UnpackedUint64ExtensionLite;
+    public const int UnpackedSint32ExtensionLiteFieldNumber = 94;
+    public static pb::GeneratedRepeatExtensionLite<global::Google.ProtocolBuffers.TestProtos.TestUnpackedExtensionsLite, int> UnpackedSint32ExtensionLite;
+    public const int UnpackedSint64ExtensionLiteFieldNumber = 95;
+    public static pb::GeneratedRepeatExtensionLite<global::Google.ProtocolBuffers.TestProtos.TestUnpackedExtensionsLite, long> UnpackedSint64ExtensionLite;
+    public const int UnpackedFixed32ExtensionLiteFieldNumber = 96;
+    [global::System.CLSCompliant(false)]
+    public static pb::GeneratedRepeatExtensionLite<global::Google.ProtocolBuffers.TestProtos.TestUnpackedExtensionsLite, uint> UnpackedFixed32ExtensionLite;
+    public const int UnpackedFixed64ExtensionLiteFieldNumber = 97;
+    [global::System.CLSCompliant(false)]
+    public static pb::GeneratedRepeatExtensionLite<global::Google.ProtocolBuffers.TestProtos.TestUnpackedExtensionsLite, ulong> UnpackedFixed64ExtensionLite;
+    public const int UnpackedSfixed32ExtensionLiteFieldNumber = 98;
+    public static pb::GeneratedRepeatExtensionLite<global::Google.ProtocolBuffers.TestProtos.TestUnpackedExtensionsLite, int> UnpackedSfixed32ExtensionLite;
+    public const int UnpackedSfixed64ExtensionLiteFieldNumber = 99;
+    public static pb::GeneratedRepeatExtensionLite<global::Google.ProtocolBuffers.TestProtos.TestUnpackedExtensionsLite, long> UnpackedSfixed64ExtensionLite;
+    public const int UnpackedFloatExtensionLiteFieldNumber = 100;
+    public static pb::GeneratedRepeatExtensionLite<global::Google.ProtocolBuffers.TestProtos.TestUnpackedExtensionsLite, float> UnpackedFloatExtensionLite;
+    public const int UnpackedDoubleExtensionLiteFieldNumber = 101;
+    public static pb::GeneratedRepeatExtensionLite<global::Google.ProtocolBuffers.TestProtos.TestUnpackedExtensionsLite, double> UnpackedDoubleExtensionLite;
+    public const int UnpackedBoolExtensionLiteFieldNumber = 102;
+    public static pb::GeneratedRepeatExtensionLite<global::Google.ProtocolBuffers.TestProtos.TestUnpackedExtensionsLite, bool> UnpackedBoolExtensionLite;
+    public const int UnpackedEnumExtensionLiteFieldNumber = 103;
+    public static pb::GeneratedRepeatExtensionLite<global::Google.ProtocolBuffers.TestProtos.TestUnpackedExtensionsLite, global::Google.ProtocolBuffers.TestProtos.UnpackedTypesForeignEnumLite> UnpackedEnumExtensionLite;
     #endregion
     
     #region Static variables
@@ -38,6 +84,132 @@ namespace Google.ProtocolBuffers.TestProtos {
           null,
           global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasLiteProtoFile.EmployeeIdLiteFieldNumber,
           pbd::FieldType.Message);
+      global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasLiteProtoFile.UnpackedInt32ExtensionLite = 
+        new pb::GeneratedRepeatExtensionLite<global::Google.ProtocolBuffers.TestProtos.TestUnpackedExtensionsLite, int>(
+          "protobuf_unittest_extra.unpacked_int32_extension_lite",
+          global::Google.ProtocolBuffers.TestProtos.TestUnpackedExtensionsLite.DefaultInstance,
+          null,
+          null,
+          global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasLiteProtoFile.UnpackedInt32ExtensionLiteFieldNumber,
+          pbd::FieldType.Int32,
+          false);
+      global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasLiteProtoFile.UnpackedInt64ExtensionLite = 
+        new pb::GeneratedRepeatExtensionLite<global::Google.ProtocolBuffers.TestProtos.TestUnpackedExtensionsLite, long>(
+          "protobuf_unittest_extra.unpacked_int64_extension_lite",
+          global::Google.ProtocolBuffers.TestProtos.TestUnpackedExtensionsLite.DefaultInstance,
+          null,
+          null,
+          global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasLiteProtoFile.UnpackedInt64ExtensionLiteFieldNumber,
+          pbd::FieldType.Int64,
+          false);
+      global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasLiteProtoFile.UnpackedUint32ExtensionLite = 
+        new pb::GeneratedRepeatExtensionLite<global::Google.ProtocolBuffers.TestProtos.TestUnpackedExtensionsLite, uint>(
+          "protobuf_unittest_extra.unpacked_uint32_extension_lite",
+          global::Google.ProtocolBuffers.TestProtos.TestUnpackedExtensionsLite.DefaultInstance,
+          null,
+          null,
+          global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasLiteProtoFile.UnpackedUint32ExtensionLiteFieldNumber,
+          pbd::FieldType.UInt32,
+          false);
+      global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasLiteProtoFile.UnpackedUint64ExtensionLite = 
+        new pb::GeneratedRepeatExtensionLite<global::Google.ProtocolBuffers.TestProtos.TestUnpackedExtensionsLite, ulong>(
+          "protobuf_unittest_extra.unpacked_uint64_extension_lite",
+          global::Google.ProtocolBuffers.TestProtos.TestUnpackedExtensionsLite.DefaultInstance,
+          null,
+          null,
+          global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasLiteProtoFile.UnpackedUint64ExtensionLiteFieldNumber,
+          pbd::FieldType.UInt64,
+          false);
+      global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasLiteProtoFile.UnpackedSint32ExtensionLite = 
+        new pb::GeneratedRepeatExtensionLite<global::Google.ProtocolBuffers.TestProtos.TestUnpackedExtensionsLite, int>(
+          "protobuf_unittest_extra.unpacked_sint32_extension_lite",
+          global::Google.ProtocolBuffers.TestProtos.TestUnpackedExtensionsLite.DefaultInstance,
+          null,
+          null,
+          global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasLiteProtoFile.UnpackedSint32ExtensionLiteFieldNumber,
+          pbd::FieldType.SInt32,
+          false);
+      global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasLiteProtoFile.UnpackedSint64ExtensionLite = 
+        new pb::GeneratedRepeatExtensionLite<global::Google.ProtocolBuffers.TestProtos.TestUnpackedExtensionsLite, long>(
+          "protobuf_unittest_extra.unpacked_sint64_extension_lite",
+          global::Google.ProtocolBuffers.TestProtos.TestUnpackedExtensionsLite.DefaultInstance,
+          null,
+          null,
+          global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasLiteProtoFile.UnpackedSint64ExtensionLiteFieldNumber,
+          pbd::FieldType.SInt64,
+          false);
+      global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasLiteProtoFile.UnpackedFixed32ExtensionLite = 
+        new pb::GeneratedRepeatExtensionLite<global::Google.ProtocolBuffers.TestProtos.TestUnpackedExtensionsLite, uint>(
+          "protobuf_unittest_extra.unpacked_fixed32_extension_lite",
+          global::Google.ProtocolBuffers.TestProtos.TestUnpackedExtensionsLite.DefaultInstance,
+          null,
+          null,
+          global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasLiteProtoFile.UnpackedFixed32ExtensionLiteFieldNumber,
+          pbd::FieldType.Fixed32,
+          false);
+      global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasLiteProtoFile.UnpackedFixed64ExtensionLite = 
+        new pb::GeneratedRepeatExtensionLite<global::Google.ProtocolBuffers.TestProtos.TestUnpackedExtensionsLite, ulong>(
+          "protobuf_unittest_extra.unpacked_fixed64_extension_lite",
+          global::Google.ProtocolBuffers.TestProtos.TestUnpackedExtensionsLite.DefaultInstance,
+          null,
+          null,
+          global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasLiteProtoFile.UnpackedFixed64ExtensionLiteFieldNumber,
+          pbd::FieldType.Fixed64,
+          false);
+      global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasLiteProtoFile.UnpackedSfixed32ExtensionLite = 
+        new pb::GeneratedRepeatExtensionLite<global::Google.ProtocolBuffers.TestProtos.TestUnpackedExtensionsLite, int>(
+          "protobuf_unittest_extra.unpacked_sfixed32_extension_lite",
+          global::Google.ProtocolBuffers.TestProtos.TestUnpackedExtensionsLite.DefaultInstance,
+          null,
+          null,
+          global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasLiteProtoFile.UnpackedSfixed32ExtensionLiteFieldNumber,
+          pbd::FieldType.SFixed32,
+          false);
+      global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasLiteProtoFile.UnpackedSfixed64ExtensionLite = 
+        new pb::GeneratedRepeatExtensionLite<global::Google.ProtocolBuffers.TestProtos.TestUnpackedExtensionsLite, long>(
+          "protobuf_unittest_extra.unpacked_sfixed64_extension_lite",
+          global::Google.ProtocolBuffers.TestProtos.TestUnpackedExtensionsLite.DefaultInstance,
+          null,
+          null,
+          global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasLiteProtoFile.UnpackedSfixed64ExtensionLiteFieldNumber,
+          pbd::FieldType.SFixed64,
+          false);
+      global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasLiteProtoFile.UnpackedFloatExtensionLite = 
+        new pb::GeneratedRepeatExtensionLite<global::Google.ProtocolBuffers.TestProtos.TestUnpackedExtensionsLite, float>(
+          "protobuf_unittest_extra.unpacked_float_extension_lite",
+          global::Google.ProtocolBuffers.TestProtos.TestUnpackedExtensionsLite.DefaultInstance,
+          null,
+          null,
+          global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasLiteProtoFile.UnpackedFloatExtensionLiteFieldNumber,
+          pbd::FieldType.Float,
+          false);
+      global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasLiteProtoFile.UnpackedDoubleExtensionLite = 
+        new pb::GeneratedRepeatExtensionLite<global::Google.ProtocolBuffers.TestProtos.TestUnpackedExtensionsLite, double>(
+          "protobuf_unittest_extra.unpacked_double_extension_lite",
+          global::Google.ProtocolBuffers.TestProtos.TestUnpackedExtensionsLite.DefaultInstance,
+          null,
+          null,
+          global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasLiteProtoFile.UnpackedDoubleExtensionLiteFieldNumber,
+          pbd::FieldType.Double,
+          false);
+      global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasLiteProtoFile.UnpackedBoolExtensionLite = 
+        new pb::GeneratedRepeatExtensionLite<global::Google.ProtocolBuffers.TestProtos.TestUnpackedExtensionsLite, bool>(
+          "protobuf_unittest_extra.unpacked_bool_extension_lite",
+          global::Google.ProtocolBuffers.TestProtos.TestUnpackedExtensionsLite.DefaultInstance,
+          null,
+          null,
+          global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasLiteProtoFile.UnpackedBoolExtensionLiteFieldNumber,
+          pbd::FieldType.Bool,
+          false);
+      global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasLiteProtoFile.UnpackedEnumExtensionLite = 
+        new pb::GeneratedRepeatExtensionLite<global::Google.ProtocolBuffers.TestProtos.TestUnpackedExtensionsLite, global::Google.ProtocolBuffers.TestProtos.UnpackedTypesForeignEnumLite>(
+          "protobuf_unittest_extra.unpacked_enum_extension_lite",
+          global::Google.ProtocolBuffers.TestProtos.TestUnpackedExtensionsLite.DefaultInstance,
+          null,
+          new EnumLiteMap<global::Google.ProtocolBuffers.TestProtos.UnpackedTypesForeignEnumLite>(),
+          global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasLiteProtoFile.UnpackedEnumExtensionLiteFieldNumber,
+          pbd::FieldType.Enum,
+          false);
     }
     #endregion
     
@@ -52,6 +224,14 @@ namespace Google.ProtocolBuffers.TestProtos {
     EXLITE_BAZ = 9,
   }
   
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+  [global::System.CodeDom.Compiler.GeneratedCodeAttribute("ProtoGen", "2.3.0.277")]
+  public enum UnpackedTypesForeignEnumLite {
+    FOREIGN_LITE_FOO = 4,
+    FOREIGN_LITE_BAR = 5,
+    FOREIGN_LITE_BAZ = 6,
+  }
+  
   #endregion
   
   #region Messages
@@ -2038,6 +2218,1425 @@ namespace Google.ProtocolBuffers.TestProtos {
     }
   }
   
+  [global::System.SerializableAttribute()]
+  [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+  [global::System.CodeDom.Compiler.GeneratedCodeAttribute("ProtoGen", "2.3.0.277")]
+  public sealed partial class TestUnpackedExtensionsLite : pb::ExtendableMessageLite<TestUnpackedExtensionsLite, TestUnpackedExtensionsLite.Builder> {
+    private TestUnpackedExtensionsLite() { }
+    private static readonly TestUnpackedExtensionsLite defaultInstance = new TestUnpackedExtensionsLite().MakeReadOnly();
+    private static readonly string[] _testUnpackedExtensionsLiteFieldNames = new string[] {  };
+    private static readonly uint[] _testUnpackedExtensionsLiteFieldTags = new uint[] {  };
+    public static TestUnpackedExtensionsLite DefaultInstance {
+      get { return defaultInstance; }
+    }
+    
+    public override TestUnpackedExtensionsLite DefaultInstanceForType {
+      get { return DefaultInstance; }
+    }
+    
+    protected override TestUnpackedExtensionsLite ThisMessage {
+      get { return this; }
+    }
+    
+    public override bool IsInitialized {
+      get {
+        if (!ExtensionsAreInitialized) return false;
+        return true;
+      }
+    }
+    
+    public override void WriteTo(pb::ICodedOutputStream output) {
+      int size = SerializedSize;
+      string[] field_names = _testUnpackedExtensionsLiteFieldNames;
+      pb::ExtendableMessageLite<TestUnpackedExtensionsLite, TestUnpackedExtensionsLite.Builder>.ExtensionWriter extensionWriter = CreateExtensionWriter(this);
+      extensionWriter.WriteUntil(536870912, output);
+    }
+    
+    private int memoizedSerializedSize = -1;
+    public override int SerializedSize {
+      get {
+        int size = memoizedSerializedSize;
+        if (size != -1) return size;
+        
+        size = 0;
+        size += ExtensionsSerializedSize;
+        memoizedSerializedSize = size;
+        return size;
+      }
+    }
+    
+    #region Lite runtime methods
+    public override int GetHashCode() {
+      int hash = GetType().GetHashCode();
+      hash ^= base.GetHashCode();
+      return hash;
+    }
+    
+    public override bool Equals(object obj) {
+      TestUnpackedExtensionsLite other = obj as TestUnpackedExtensionsLite;
+      if (other == null) return false;
+      if (!base.Equals(other)) return false;
+      return true;
+    }
+    
+    public override void PrintTo(global::System.IO.TextWriter writer) {
+      base.PrintTo(writer);
+    }
+    #endregion
+    
+    public static TestUnpackedExtensionsLite ParseFrom(pb::ByteString data) {
+      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
+    }
+    public static TestUnpackedExtensionsLite ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
+    }
+    public static TestUnpackedExtensionsLite ParseFrom(byte[] data) {
+      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
+    }
+    public static TestUnpackedExtensionsLite ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
+    }
+    public static TestUnpackedExtensionsLite ParseFrom(global::System.IO.Stream input) {
+      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
+    }
+    public static TestUnpackedExtensionsLite ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
+    }
+    public static TestUnpackedExtensionsLite ParseDelimitedFrom(global::System.IO.Stream input) {
+      return CreateBuilder().MergeDelimitedFrom(input).BuildParsed();
+    }
+    public static TestUnpackedExtensionsLite ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
+      return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed();
+    }
+    public static TestUnpackedExtensionsLite ParseFrom(pb::ICodedInputStream input) {
+      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
+    }
+    public static TestUnpackedExtensionsLite ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
+    }
+    private TestUnpackedExtensionsLite MakeReadOnly() {
+      return this;
+    }
+    
+    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(TestUnpackedExtensionsLite prototype) {
+      return new Builder(prototype);
+    }
+    
+    [global::System.SerializableAttribute()]
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("ProtoGen", "2.3.0.277")]
+    public sealed partial class Builder : pb::ExtendableBuilderLite<TestUnpackedExtensionsLite, Builder> {
+      protected override Builder ThisBuilder {
+        get { return this; }
+      }
+      public Builder() {
+        result = DefaultInstance;
+        resultIsReadOnly = true;
+      }
+      internal Builder(TestUnpackedExtensionsLite cloneFrom) {
+        result = cloneFrom;
+        resultIsReadOnly = true;
+      }
+      
+      private bool resultIsReadOnly;
+      private TestUnpackedExtensionsLite result;
+      
+      private TestUnpackedExtensionsLite PrepareBuilder() {
+        if (resultIsReadOnly) {
+          TestUnpackedExtensionsLite original = result;
+          result = new TestUnpackedExtensionsLite();
+          resultIsReadOnly = false;
+          MergeFrom(original);
+        }
+        return result;
+      }
+      
+      public override bool IsInitialized {
+        get { return result.IsInitialized; }
+      }
+      
+      protected override TestUnpackedExtensionsLite MessageBeingBuilt {
+        get { return PrepareBuilder(); }
+      }
+      
+      public override Builder Clear() {
+        result = DefaultInstance;
+        resultIsReadOnly = true;
+        return this;
+      }
+      
+      public override Builder Clone() {
+        if (resultIsReadOnly) {
+          return new Builder(result);
+        } else {
+          return new Builder().MergeFrom(result);
+        }
+      }
+      
+      public override TestUnpackedExtensionsLite DefaultInstanceForType {
+        get { return global::Google.ProtocolBuffers.TestProtos.TestUnpackedExtensionsLite.DefaultInstance; }
+      }
+      
+      public override TestUnpackedExtensionsLite BuildPartial() {
+        if (resultIsReadOnly) {
+          return result;
+        }
+        resultIsReadOnly = true;
+        return result.MakeReadOnly();
+      }
+      
+      public override Builder MergeFrom(pb::IMessageLite other) {
+        if (other is TestUnpackedExtensionsLite) {
+          return MergeFrom((TestUnpackedExtensionsLite) other);
+        } else {
+          base.MergeFrom(other);
+          return this;
+        }
+      }
+      
+      public override Builder MergeFrom(TestUnpackedExtensionsLite other) {
+        if (other == global::Google.ProtocolBuffers.TestProtos.TestUnpackedExtensionsLite.DefaultInstance) return this;
+        PrepareBuilder();
+          this.MergeExtensionFields(other);
+        return this;
+      }
+      
+      public override Builder MergeFrom(pb::ICodedInputStream input) {
+        return MergeFrom(input, pb::ExtensionRegistry.Empty);
+      }
+      
+      public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
+        PrepareBuilder();
+        uint tag;
+        string field_name;
+        while (input.ReadTag(out tag, out field_name)) {
+          if(tag == 0 && field_name != null) {
+            int field_ordinal = global::System.Array.BinarySearch(_testUnpackedExtensionsLiteFieldNames, field_name, global::System.StringComparer.Ordinal);
+            if(field_ordinal >= 0)
+              tag = _testUnpackedExtensionsLiteFieldTags[field_ordinal];
+            else {
+              ParseUnknownField(input, extensionRegistry, tag, field_name);
+              continue;
+            }
+          }
+          switch (tag) {
+            case 0: {
+              throw pb::InvalidProtocolBufferException.InvalidTag();
+            }
+            default: {
+              if (pb::WireFormat.IsEndGroupTag(tag)) {
+                return this;
+              }
+              ParseUnknownField(input, extensionRegistry, tag, field_name);
+              break;
+            }
+          }
+        }
+        
+        return this;
+      }
+      
+    }
+    static TestUnpackedExtensionsLite() {
+      object.ReferenceEquals(global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasLiteProtoFile.Descriptor, null);
+    }
+  }
+  
+  [global::System.SerializableAttribute()]
+  [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+  [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+  [global::System.CodeDom.Compiler.GeneratedCodeAttribute("ProtoGen", "2.3.0.277")]
+  public sealed partial class TestUnpackedTypesLite : pb::GeneratedMessageLite<TestUnpackedTypesLite, TestUnpackedTypesLite.Builder> {
+    private TestUnpackedTypesLite() { }
+    private static readonly TestUnpackedTypesLite defaultInstance = new TestUnpackedTypesLite().MakeReadOnly();
+    private static readonly string[] _testUnpackedTypesLiteFieldNames = new string[] { "unpacked_bool", "unpacked_double", "unpacked_enum", "unpacked_fixed32", "unpacked_fixed64", "unpacked_float", "unpacked_int32", "unpacked_int64", "unpacked_sfixed32", "unpacked_sfixed64", "unpacked_sint32", "unpacked_sint64", "unpacked_uint32", "unpacked_uint64" };
+    private static readonly uint[] _testUnpackedTypesLiteFieldTags = new uint[] { 816, 809, 824, 773, 777, 805, 720, 728, 789, 793, 752, 760, 736, 744 };
+    public static TestUnpackedTypesLite DefaultInstance {
+      get { return defaultInstance; }
+    }
+    
+    public override TestUnpackedTypesLite DefaultInstanceForType {
+      get { return DefaultInstance; }
+    }
+    
+    protected override TestUnpackedTypesLite ThisMessage {
+      get { return this; }
+    }
+    
+    public const int UnpackedInt32FieldNumber = 90;
+    private pbc::PopsicleList<int> unpackedInt32_ = new pbc::PopsicleList<int>();
+    public scg::IList<int> UnpackedInt32List {
+      get { return pbc::Lists.AsReadOnly(unpackedInt32_); }
+    }
+    public int UnpackedInt32Count {
+      get { return unpackedInt32_.Count; }
+    }
+    public int GetUnpackedInt32(int index) {
+      return unpackedInt32_[index];
+    }
+    
+    public const int UnpackedInt64FieldNumber = 91;
+    private pbc::PopsicleList<long> unpackedInt64_ = new pbc::PopsicleList<long>();
+    public scg::IList<long> UnpackedInt64List {
+      get { return pbc::Lists.AsReadOnly(unpackedInt64_); }
+    }
+    public int UnpackedInt64Count {
+      get { return unpackedInt64_.Count; }
+    }
+    public long GetUnpackedInt64(int index) {
+      return unpackedInt64_[index];
+    }
+    
+    public const int UnpackedUint32FieldNumber = 92;
+    private pbc::PopsicleList<uint> unpackedUint32_ = new pbc::PopsicleList<uint>();
+    [global::System.CLSCompliant(false)]
+    public scg::IList<uint> UnpackedUint32List {
+      get { return pbc::Lists.AsReadOnly(unpackedUint32_); }
+    }
+    public int UnpackedUint32Count {
+      get { return unpackedUint32_.Count; }
+    }
+    [global::System.CLSCompliant(false)]
+    public uint GetUnpackedUint32(int index) {
+      return unpackedUint32_[index];
+    }
+    
+    public const int UnpackedUint64FieldNumber = 93;
+    private pbc::PopsicleList<ulong> unpackedUint64_ = new pbc::PopsicleList<ulong>();
+    [global::System.CLSCompliant(false)]
+    public scg::IList<ulong> UnpackedUint64List {
+      get { return pbc::Lists.AsReadOnly(unpackedUint64_); }
+    }
+    public int UnpackedUint64Count {
+      get { return unpackedUint64_.Count; }
+    }
+    [global::System.CLSCompliant(false)]
+    public ulong GetUnpackedUint64(int index) {
+      return unpackedUint64_[index];
+    }
+    
+    public const int UnpackedSint32FieldNumber = 94;
+    private pbc::PopsicleList<int> unpackedSint32_ = new pbc::PopsicleList<int>();
+    public scg::IList<int> UnpackedSint32List {
+      get { return pbc::Lists.AsReadOnly(unpackedSint32_); }
+    }
+    public int UnpackedSint32Count {
+      get { return unpackedSint32_.Count; }
+    }
+    public int GetUnpackedSint32(int index) {
+      return unpackedSint32_[index];
+    }
+    
+    public const int UnpackedSint64FieldNumber = 95;
+    private pbc::PopsicleList<long> unpackedSint64_ = new pbc::PopsicleList<long>();
+    public scg::IList<long> UnpackedSint64List {
+      get { return pbc::Lists.AsReadOnly(unpackedSint64_); }
+    }
+    public int UnpackedSint64Count {
+      get { return unpackedSint64_.Count; }
+    }
+    public long GetUnpackedSint64(int index) {
+      return unpackedSint64_[index];
+    }
+    
+    public const int UnpackedFixed32FieldNumber = 96;
+    private pbc::PopsicleList<uint> unpackedFixed32_ = new pbc::PopsicleList<uint>();
+    [global::System.CLSCompliant(false)]
+    public scg::IList<uint> UnpackedFixed32List {
+      get { return pbc::Lists.AsReadOnly(unpackedFixed32_); }
+    }
+    public int UnpackedFixed32Count {
+      get { return unpackedFixed32_.Count; }
+    }
+    [global::System.CLSCompliant(false)]
+    public uint GetUnpackedFixed32(int index) {
+      return unpackedFixed32_[index];
+    }
+    
+    public const int UnpackedFixed64FieldNumber = 97;
+    private pbc::PopsicleList<ulong> unpackedFixed64_ = new pbc::PopsicleList<ulong>();
+    [global::System.CLSCompliant(false)]
+    public scg::IList<ulong> UnpackedFixed64List {
+      get { return pbc::Lists.AsReadOnly(unpackedFixed64_); }
+    }
+    public int UnpackedFixed64Count {
+      get { return unpackedFixed64_.Count; }
+    }
+    [global::System.CLSCompliant(false)]
+    public ulong GetUnpackedFixed64(int index) {
+      return unpackedFixed64_[index];
+    }
+    
+    public const int UnpackedSfixed32FieldNumber = 98;
+    private pbc::PopsicleList<int> unpackedSfixed32_ = new pbc::PopsicleList<int>();
+    public scg::IList<int> UnpackedSfixed32List {
+      get { return pbc::Lists.AsReadOnly(unpackedSfixed32_); }
+    }
+    public int UnpackedSfixed32Count {
+      get { return unpackedSfixed32_.Count; }
+    }
+    public int GetUnpackedSfixed32(int index) {
+      return unpackedSfixed32_[index];
+    }
+    
+    public const int UnpackedSfixed64FieldNumber = 99;
+    private pbc::PopsicleList<long> unpackedSfixed64_ = new pbc::PopsicleList<long>();
+    public scg::IList<long> UnpackedSfixed64List {
+      get { return pbc::Lists.AsReadOnly(unpackedSfixed64_); }
+    }
+    public int UnpackedSfixed64Count {
+      get { return unpackedSfixed64_.Count; }
+    }
+    public long GetUnpackedSfixed64(int index) {
+      return unpackedSfixed64_[index];
+    }
+    
+    public const int UnpackedFloatFieldNumber = 100;
+    private pbc::PopsicleList<float> unpackedFloat_ = new pbc::PopsicleList<float>();
+    public scg::IList<float> UnpackedFloatList {
+      get { return pbc::Lists.AsReadOnly(unpackedFloat_); }
+    }
+    public int UnpackedFloatCount {
+      get { return unpackedFloat_.Count; }
+    }
+    public float GetUnpackedFloat(int index) {
+      return unpackedFloat_[index];
+    }
+    
+    public const int UnpackedDoubleFieldNumber = 101;
+    private pbc::PopsicleList<double> unpackedDouble_ = new pbc::PopsicleList<double>();
+    public scg::IList<double> UnpackedDoubleList {
+      get { return pbc::Lists.AsReadOnly(unpackedDouble_); }
+    }
+    public int UnpackedDoubleCount {
+      get { return unpackedDouble_.Count; }
+    }
+    public double GetUnpackedDouble(int index) {
+      return unpackedDouble_[index];
+    }
+    
+    public const int UnpackedBoolFieldNumber = 102;
+    private pbc::PopsicleList<bool> unpackedBool_ = new pbc::PopsicleList<bool>();
+    public scg::IList<bool> UnpackedBoolList {
+      get { return pbc::Lists.AsReadOnly(unpackedBool_); }
+    }
+    public int UnpackedBoolCount {
+      get { return unpackedBool_.Count; }
+    }
+    public bool GetUnpackedBool(int index) {
+      return unpackedBool_[index];
+    }
+    
+    public const int UnpackedEnumFieldNumber = 103;
+    private pbc::PopsicleList<global::Google.ProtocolBuffers.TestProtos.UnpackedTypesForeignEnumLite> unpackedEnum_ = new pbc::PopsicleList<global::Google.ProtocolBuffers.TestProtos.UnpackedTypesForeignEnumLite>();
+    public scg::IList<global::Google.ProtocolBuffers.TestProtos.UnpackedTypesForeignEnumLite> UnpackedEnumList {
+      get { return pbc::Lists.AsReadOnly(unpackedEnum_); }
+    }
+    public int UnpackedEnumCount {
+      get { return unpackedEnum_.Count; }
+    }
+    public global::Google.ProtocolBuffers.TestProtos.UnpackedTypesForeignEnumLite GetUnpackedEnum(int index) {
+      return unpackedEnum_[index];
+    }
+    
+    public override bool IsInitialized {
+      get {
+        return true;
+      }
+    }
+    
+    public override void WriteTo(pb::ICodedOutputStream output) {
+      int size = SerializedSize;
+      string[] field_names = _testUnpackedTypesLiteFieldNames;
+      if (unpackedInt32_.Count > 0) {
+        output.WriteInt32Array(90, field_names[6], unpackedInt32_);
+      }
+      if (unpackedInt64_.Count > 0) {
+        output.WriteInt64Array(91, field_names[7], unpackedInt64_);
+      }
+      if (unpackedUint32_.Count > 0) {
+        output.WriteUInt32Array(92, field_names[12], unpackedUint32_);
+      }
+      if (unpackedUint64_.Count > 0) {
+        output.WriteUInt64Array(93, field_names[13], unpackedUint64_);
+      }
+      if (unpackedSint32_.Count > 0) {
+        output.WriteSInt32Array(94, field_names[10], unpackedSint32_);
+      }
+      if (unpackedSint64_.Count > 0) {
+        output.WriteSInt64Array(95, field_names[11], unpackedSint64_);
+      }
+      if (unpackedFixed32_.Count > 0) {
+        output.WriteFixed32Array(96, field_names[3], unpackedFixed32_);
+      }
+      if (unpackedFixed64_.Count > 0) {
+        output.WriteFixed64Array(97, field_names[4], unpackedFixed64_);
+      }
+      if (unpackedSfixed32_.Count > 0) {
+        output.WriteSFixed32Array(98, field_names[8], unpackedSfixed32_);
+      }
+      if (unpackedSfixed64_.Count > 0) {
+        output.WriteSFixed64Array(99, field_names[9], unpackedSfixed64_);
+      }
+      if (unpackedFloat_.Count > 0) {
+        output.WriteFloatArray(100, field_names[5], unpackedFloat_);
+      }
+      if (unpackedDouble_.Count > 0) {
+        output.WriteDoubleArray(101, field_names[1], unpackedDouble_);
+      }
+      if (unpackedBool_.Count > 0) {
+        output.WriteBoolArray(102, field_names[0], unpackedBool_);
+      }
+      if (unpackedEnum_.Count > 0) {
+        output.WriteEnumArray(103, field_names[2], unpackedEnum_);
+      }
+    }
+    
+    private int memoizedSerializedSize = -1;
+    public override int SerializedSize {
+      get {
+        int size = memoizedSerializedSize;
+        if (size != -1) return size;
+        
+        size = 0;
+        {
+          int dataSize = 0;
+          foreach (int element in UnpackedInt32List) {
+            dataSize += pb::CodedOutputStream.ComputeInt32SizeNoTag(element);
+          }
+          size += dataSize;
+          size += 2 * unpackedInt32_.Count;
+        }
+        {
+          int dataSize = 0;
+          foreach (long element in UnpackedInt64List) {
+            dataSize += pb::CodedOutputStream.ComputeInt64SizeNoTag(element);
+          }
+          size += dataSize;
+          size += 2 * unpackedInt64_.Count;
+        }
+        {
+          int dataSize = 0;
+          foreach (uint element in UnpackedUint32List) {
+            dataSize += pb::CodedOutputStream.ComputeUInt32SizeNoTag(element);
+          }
+          size += dataSize;
+          size += 2 * unpackedUint32_.Count;
+        }
+        {
+          int dataSize = 0;
+          foreach (ulong element in UnpackedUint64List) {
+            dataSize += pb::CodedOutputStream.ComputeUInt64SizeNoTag(element);
+          }
+          size += dataSize;
+          size += 2 * unpackedUint64_.Count;
+        }
+        {
+          int dataSize = 0;
+          foreach (int element in UnpackedSint32List) {
+            dataSize += pb::CodedOutputStream.ComputeSInt32SizeNoTag(element);
+          }
+          size += dataSize;
+          size += 2 * unpackedSint32_.Count;
+        }
+        {
+          int dataSize = 0;
+          foreach (long element in UnpackedSint64List) {
+            dataSize += pb::CodedOutputStream.ComputeSInt64SizeNoTag(element);
+          }
+          size += dataSize;
+          size += 2 * unpackedSint64_.Count;
+        }
+        {
+          int dataSize = 0;
+          dataSize = 4 * unpackedFixed32_.Count;
+          size += dataSize;
+          size += 2 * unpackedFixed32_.Count;
+        }
+        {
+          int dataSize = 0;
+          dataSize = 8 * unpackedFixed64_.Count;
+          size += dataSize;
+          size += 2 * unpackedFixed64_.Count;
+        }
+        {
+          int dataSize = 0;
+          dataSize = 4 * unpackedSfixed32_.Count;
+          size += dataSize;
+          size += 2 * unpackedSfixed32_.Count;
+        }
+        {
+          int dataSize = 0;
+          dataSize = 8 * unpackedSfixed64_.Count;
+          size += dataSize;
+          size += 2 * unpackedSfixed64_.Count;
+        }
+        {
+          int dataSize = 0;
+          dataSize = 4 * unpackedFloat_.Count;
+          size += dataSize;
+          size += 2 * unpackedFloat_.Count;
+        }
+        {
+          int dataSize = 0;
+          dataSize = 8 * unpackedDouble_.Count;
+          size += dataSize;
+          size += 2 * unpackedDouble_.Count;
+        }
+        {
+          int dataSize = 0;
+          dataSize = 1 * unpackedBool_.Count;
+          size += dataSize;
+          size += 2 * unpackedBool_.Count;
+        }
+        {
+          int dataSize = 0;
+          if (unpackedEnum_.Count > 0) {
+            foreach (global::Google.ProtocolBuffers.TestProtos.UnpackedTypesForeignEnumLite element in unpackedEnum_) {
+              dataSize += pb::CodedOutputStream.ComputeEnumSizeNoTag((int) element);
+            }
+            size += dataSize;
+            size += 2 * unpackedEnum_.Count;
+          }
+        }
+        memoizedSerializedSize = size;
+        return size;
+      }
+    }
+    
+    #region Lite runtime methods
+    public override int GetHashCode() {
+      int hash = GetType().GetHashCode();
+      foreach(int i in unpackedInt32_)
+        hash ^= i.GetHashCode();
+      foreach(long i in unpackedInt64_)
+        hash ^= i.GetHashCode();
+      foreach(uint i in unpackedUint32_)
+        hash ^= i.GetHashCode();
+      foreach(ulong i in unpackedUint64_)
+        hash ^= i.GetHashCode();
+      foreach(int i in unpackedSint32_)
+        hash ^= i.GetHashCode();
+      foreach(long i in unpackedSint64_)
+        hash ^= i.GetHashCode();
+      foreach(uint i in unpackedFixed32_)
+        hash ^= i.GetHashCode();
+      foreach(ulong i in unpackedFixed64_)
+        hash ^= i.GetHashCode();
+      foreach(int i in unpackedSfixed32_)
+        hash ^= i.GetHashCode();
+      foreach(long i in unpackedSfixed64_)
+        hash ^= i.GetHashCode();
+      foreach(float i in unpackedFloat_)
+        hash ^= i.GetHashCode();
+      foreach(double i in unpackedDouble_)
+        hash ^= i.GetHashCode();
+      foreach(bool i in unpackedBool_)
+        hash ^= i.GetHashCode();
+      foreach(global::Google.ProtocolBuffers.TestProtos.UnpackedTypesForeignEnumLite i in unpackedEnum_)
+        hash ^= i.GetHashCode();
+      return hash;
+    }
+    
+    public override bool Equals(object obj) {
+      TestUnpackedTypesLite other = obj as TestUnpackedTypesLite;
+      if (other == null) return false;
+      if(unpackedInt32_.Count != other.unpackedInt32_.Count) return false;
+      for(int ix=0; ix < unpackedInt32_.Count; ix++)
+        if(!unpackedInt32_[ix].Equals(other.unpackedInt32_[ix])) return false;
+      if(unpackedInt64_.Count != other.unpackedInt64_.Count) return false;
+      for(int ix=0; ix < unpackedInt64_.Count; ix++)
+        if(!unpackedInt64_[ix].Equals(other.unpackedInt64_[ix])) return false;
+      if(unpackedUint32_.Count != other.unpackedUint32_.Count) return false;
+      for(int ix=0; ix < unpackedUint32_.Count; ix++)
+        if(!unpackedUint32_[ix].Equals(other.unpackedUint32_[ix])) return false;
+      if(unpackedUint64_.Count != other.unpackedUint64_.Count) return false;
+      for(int ix=0; ix < unpackedUint64_.Count; ix++)
+        if(!unpackedUint64_[ix].Equals(other.unpackedUint64_[ix])) return false;
+      if(unpackedSint32_.Count != other.unpackedSint32_.Count) return false;
+      for(int ix=0; ix < unpackedSint32_.Count; ix++)
+        if(!unpackedSint32_[ix].Equals(other.unpackedSint32_[ix])) return false;
+      if(unpackedSint64_.Count != other.unpackedSint64_.Count) return false;
+      for(int ix=0; ix < unpackedSint64_.Count; ix++)
+        if(!unpackedSint64_[ix].Equals(other.unpackedSint64_[ix])) return false;
+      if(unpackedFixed32_.Count != other.unpackedFixed32_.Count) return false;
+      for(int ix=0; ix < unpackedFixed32_.Count; ix++)
+        if(!unpackedFixed32_[ix].Equals(other.unpackedFixed32_[ix])) return false;
+      if(unpackedFixed64_.Count != other.unpackedFixed64_.Count) return false;
+      for(int ix=0; ix < unpackedFixed64_.Count; ix++)
+        if(!unpackedFixed64_[ix].Equals(other.unpackedFixed64_[ix])) return false;
+      if(unpackedSfixed32_.Count != other.unpackedSfixed32_.Count) return false;
+      for(int ix=0; ix < unpackedSfixed32_.Count; ix++)
+        if(!unpackedSfixed32_[ix].Equals(other.unpackedSfixed32_[ix])) return false;
+      if(unpackedSfixed64_.Count != other.unpackedSfixed64_.Count) return false;
+      for(int ix=0; ix < unpackedSfixed64_.Count; ix++)
+        if(!unpackedSfixed64_[ix].Equals(other.unpackedSfixed64_[ix])) return false;
+      if(unpackedFloat_.Count != other.unpackedFloat_.Count) return false;
+      for(int ix=0; ix < unpackedFloat_.Count; ix++)
+        if(!unpackedFloat_[ix].Equals(other.unpackedFloat_[ix])) return false;
+      if(unpackedDouble_.Count != other.unpackedDouble_.Count) return false;
+      for(int ix=0; ix < unpackedDouble_.Count; ix++)
+        if(!unpackedDouble_[ix].Equals(other.unpackedDouble_[ix])) return false;
+      if(unpackedBool_.Count != other.unpackedBool_.Count) return false;
+      for(int ix=0; ix < unpackedBool_.Count; ix++)
+        if(!unpackedBool_[ix].Equals(other.unpackedBool_[ix])) return false;
+      if(unpackedEnum_.Count != other.unpackedEnum_.Count) return false;
+      for(int ix=0; ix < unpackedEnum_.Count; ix++)
+        if(!unpackedEnum_[ix].Equals(other.unpackedEnum_[ix])) return false;
+      return true;
+    }
+    
+    public override void PrintTo(global::System.IO.TextWriter writer) {
+      PrintField("unpacked_int32", unpackedInt32_, writer);
+      PrintField("unpacked_int64", unpackedInt64_, writer);
+      PrintField("unpacked_uint32", unpackedUint32_, writer);
+      PrintField("unpacked_uint64", unpackedUint64_, writer);
+      PrintField("unpacked_sint32", unpackedSint32_, writer);
+      PrintField("unpacked_sint64", unpackedSint64_, writer);
+      PrintField("unpacked_fixed32", unpackedFixed32_, writer);
+      PrintField("unpacked_fixed64", unpackedFixed64_, writer);
+      PrintField("unpacked_sfixed32", unpackedSfixed32_, writer);
+      PrintField("unpacked_sfixed64", unpackedSfixed64_, writer);
+      PrintField("unpacked_float", unpackedFloat_, writer);
+      PrintField("unpacked_double", unpackedDouble_, writer);
+      PrintField("unpacked_bool", unpackedBool_, writer);
+      PrintField("unpacked_enum", unpackedEnum_, writer);
+    }
+    #endregion
+    
+    public static TestUnpackedTypesLite ParseFrom(pb::ByteString data) {
+      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
+    }
+    public static TestUnpackedTypesLite ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
+    }
+    public static TestUnpackedTypesLite ParseFrom(byte[] data) {
+      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
+    }
+    public static TestUnpackedTypesLite ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
+    }
+    public static TestUnpackedTypesLite ParseFrom(global::System.IO.Stream input) {
+      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
+    }
+    public static TestUnpackedTypesLite ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
+    }
+    public static TestUnpackedTypesLite ParseDelimitedFrom(global::System.IO.Stream input) {
+      return CreateBuilder().MergeDelimitedFrom(input).BuildParsed();
+    }
+    public static TestUnpackedTypesLite ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
+      return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed();
+    }
+    public static TestUnpackedTypesLite ParseFrom(pb::ICodedInputStream input) {
+      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
+    }
+    public static TestUnpackedTypesLite ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
+      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
+    }
+    private TestUnpackedTypesLite MakeReadOnly() {
+      unpackedInt32_.MakeReadOnly();
+      unpackedInt64_.MakeReadOnly();
+      unpackedUint32_.MakeReadOnly();
+      unpackedUint64_.MakeReadOnly();
+      unpackedSint32_.MakeReadOnly();
+      unpackedSint64_.MakeReadOnly();
+      unpackedFixed32_.MakeReadOnly();
+      unpackedFixed64_.MakeReadOnly();
+      unpackedSfixed32_.MakeReadOnly();
+      unpackedSfixed64_.MakeReadOnly();
+      unpackedFloat_.MakeReadOnly();
+      unpackedDouble_.MakeReadOnly();
+      unpackedBool_.MakeReadOnly();
+      unpackedEnum_.MakeReadOnly();
+      return this;
+    }
+    
+    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(TestUnpackedTypesLite prototype) {
+      return new Builder(prototype);
+    }
+    
+    [global::System.SerializableAttribute()]
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("ProtoGen", "2.3.0.277")]
+    public sealed partial class Builder : pb::GeneratedBuilderLite<TestUnpackedTypesLite, Builder> {
+      protected override Builder ThisBuilder {
+        get { return this; }
+      }
+      public Builder() {
+        result = DefaultInstance;
+        resultIsReadOnly = true;
+      }
+      internal Builder(TestUnpackedTypesLite cloneFrom) {
+        result = cloneFrom;
+        resultIsReadOnly = true;
+      }
+      
+      private bool resultIsReadOnly;
+      private TestUnpackedTypesLite result;
+      
+      private TestUnpackedTypesLite PrepareBuilder() {
+        if (resultIsReadOnly) {
+          TestUnpackedTypesLite original = result;
+          result = new TestUnpackedTypesLite();
+          resultIsReadOnly = false;
+          MergeFrom(original);
+        }
+        return result;
+      }
+      
+      public override bool IsInitialized {
+        get { return result.IsInitialized; }
+      }
+      
+      protected override TestUnpackedTypesLite MessageBeingBuilt {
+        get { return PrepareBuilder(); }
+      }
+      
+      public override Builder Clear() {
+        result = DefaultInstance;
+        resultIsReadOnly = true;
+        return this;
+      }
+      
+      public override Builder Clone() {
+        if (resultIsReadOnly) {
+          return new Builder(result);
+        } else {
+          return new Builder().MergeFrom(result);
+        }
+      }
+      
+      public override TestUnpackedTypesLite DefaultInstanceForType {
+        get { return global::Google.ProtocolBuffers.TestProtos.TestUnpackedTypesLite.DefaultInstance; }
+      }
+      
+      public override TestUnpackedTypesLite BuildPartial() {
+        if (resultIsReadOnly) {
+          return result;
+        }
+        resultIsReadOnly = true;
+        return result.MakeReadOnly();
+      }
+      
+      public override Builder MergeFrom(pb::IMessageLite other) {
+        if (other is TestUnpackedTypesLite) {
+          return MergeFrom((TestUnpackedTypesLite) other);
+        } else {
+          base.MergeFrom(other);
+          return this;
+        }
+      }
+      
+      public override Builder MergeFrom(TestUnpackedTypesLite other) {
+        if (other == global::Google.ProtocolBuffers.TestProtos.TestUnpackedTypesLite.DefaultInstance) return this;
+        PrepareBuilder();
+        if (other.unpackedInt32_.Count != 0) {
+          result.unpackedInt32_.Add(other.unpackedInt32_);
+        }
+        if (other.unpackedInt64_.Count != 0) {
+          result.unpackedInt64_.Add(other.unpackedInt64_);
+        }
+        if (other.unpackedUint32_.Count != 0) {
+          result.unpackedUint32_.Add(other.unpackedUint32_);
+        }
+        if (other.unpackedUint64_.Count != 0) {
+          result.unpackedUint64_.Add(other.unpackedUint64_);
+        }
+        if (other.unpackedSint32_.Count != 0) {
+          result.unpackedSint32_.Add(other.unpackedSint32_);
+        }
+        if (other.unpackedSint64_.Count != 0) {
+          result.unpackedSint64_.Add(other.unpackedSint64_);
+        }
+        if (other.unpackedFixed32_.Count != 0) {
+          result.unpackedFixed32_.Add(other.unpackedFixed32_);
+        }
+        if (other.unpackedFixed64_.Count != 0) {
+          result.unpackedFixed64_.Add(other.unpackedFixed64_);
+        }
+        if (other.unpackedSfixed32_.Count != 0) {
+          result.unpackedSfixed32_.Add(other.unpackedSfixed32_);
+        }
+        if (other.unpackedSfixed64_.Count != 0) {
+          result.unpackedSfixed64_.Add(other.unpackedSfixed64_);
+        }
+        if (other.unpackedFloat_.Count != 0) {
+          result.unpackedFloat_.Add(other.unpackedFloat_);
+        }
+        if (other.unpackedDouble_.Count != 0) {
+          result.unpackedDouble_.Add(other.unpackedDouble_);
+        }
+        if (other.unpackedBool_.Count != 0) {
+          result.unpackedBool_.Add(other.unpackedBool_);
+        }
+        if (other.unpackedEnum_.Count != 0) {
+          result.unpackedEnum_.Add(other.unpackedEnum_);
+        }
+        return this;
+      }
+      
+      public override Builder MergeFrom(pb::ICodedInputStream input) {
+        return MergeFrom(input, pb::ExtensionRegistry.Empty);
+      }
+      
+      public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
+        PrepareBuilder();
+        uint tag;
+        string field_name;
+        while (input.ReadTag(out tag, out field_name)) {
+          if(tag == 0 && field_name != null) {
+            int field_ordinal = global::System.Array.BinarySearch(_testUnpackedTypesLiteFieldNames, field_name, global::System.StringComparer.Ordinal);
+            if(field_ordinal >= 0)
+              tag = _testUnpackedTypesLiteFieldTags[field_ordinal];
+            else {
+              ParseUnknownField(input, extensionRegistry, tag, field_name);
+              continue;
+            }
+          }
+          switch (tag) {
+            case 0: {
+              throw pb::InvalidProtocolBufferException.InvalidTag();
+            }
+            default: {
+              if (pb::WireFormat.IsEndGroupTag(tag)) {
+                return this;
+              }
+              ParseUnknownField(input, extensionRegistry, tag, field_name);
+              break;
+            }
+            case 722:
+            case 720: {
+              input.ReadInt32Array(tag, field_name, result.unpackedInt32_);
+              break;
+            }
+            case 730:
+            case 728: {
+              input.ReadInt64Array(tag, field_name, result.unpackedInt64_);
+              break;
+            }
+            case 738:
+            case 736: {
+              input.ReadUInt32Array(tag, field_name, result.unpackedUint32_);
+              break;
+            }
+            case 746:
+            case 744: {
+              input.ReadUInt64Array(tag, field_name, result.unpackedUint64_);
+              break;
+            }
+            case 754:
+            case 752: {
+              input.ReadSInt32Array(tag, field_name, result.unpackedSint32_);
+              break;
+            }
+            case 762:
+            case 760: {
+              input.ReadSInt64Array(tag, field_name, result.unpackedSint64_);
+              break;
+            }
+            case 770:
+            case 773: {
+              input.ReadFixed32Array(tag, field_name, result.unpackedFixed32_);
+              break;
+            }
+            case 778:
+            case 777: {
+              input.ReadFixed64Array(tag, field_name, result.unpackedFixed64_);
+              break;
+            }
+            case 786:
+            case 789: {
+              input.ReadSFixed32Array(tag, field_name, result.unpackedSfixed32_);
+              break;
+            }
+            case 794:
+            case 793: {
+              input.ReadSFixed64Array(tag, field_name, result.unpackedSfixed64_);
+              break;
+            }
+            case 802:
+            case 805: {
+              input.ReadFloatArray(tag, field_name, result.unpackedFloat_);
+              break;
+            }
+            case 810:
+            case 809: {
+              input.ReadDoubleArray(tag, field_name, result.unpackedDouble_);
+              break;
+            }
+            case 818:
+            case 816: {
+              input.ReadBoolArray(tag, field_name, result.unpackedBool_);
+              break;
+            }
+            case 826:
+            case 824: {
+              scg::ICollection<object> unknownItems;
+              input.ReadEnumArray<global::Google.ProtocolBuffers.TestProtos.UnpackedTypesForeignEnumLite>(tag, field_name, result.unpackedEnum_, out unknownItems);
+              break;
+            }
+          }
+        }
+        
+        return this;
+      }
+      
+      
+      public pbc::IPopsicleList<int> UnpackedInt32List {
+        get { return PrepareBuilder().unpackedInt32_; }
+      }
+      public int UnpackedInt32Count {
+        get { return result.UnpackedInt32Count; }
+      }
+      public int GetUnpackedInt32(int index) {
+        return result.GetUnpackedInt32(index);
+      }
+      public Builder SetUnpackedInt32(int index, int value) {
+        PrepareBuilder();
+        result.unpackedInt32_[index] = value;
+        return this;
+      }
+      public Builder AddUnpackedInt32(int value) {
+        PrepareBuilder();
+        result.unpackedInt32_.Add(value);
+        return this;
+      }
+      public Builder AddRangeUnpackedInt32(scg::IEnumerable<int> values) {
+        PrepareBuilder();
+        result.unpackedInt32_.Add(values);
+        return this;
+      }
+      public Builder ClearUnpackedInt32() {
+        PrepareBuilder();
+        result.unpackedInt32_.Clear();
+        return this;
+      }
+      
+      public pbc::IPopsicleList<long> UnpackedInt64List {
+        get { return PrepareBuilder().unpackedInt64_; }
+      }
+      public int UnpackedInt64Count {
+        get { return result.UnpackedInt64Count; }
+      }
+      public long GetUnpackedInt64(int index) {
+        return result.GetUnpackedInt64(index);
+      }
+      public Builder SetUnpackedInt64(int index, long value) {
+        PrepareBuilder();
+        result.unpackedInt64_[index] = value;
+        return this;
+      }
+      public Builder AddUnpackedInt64(long value) {
+        PrepareBuilder();
+        result.unpackedInt64_.Add(value);
+        return this;
+      }
+      public Builder AddRangeUnpackedInt64(scg::IEnumerable<long> values) {
+        PrepareBuilder();
+        result.unpackedInt64_.Add(values);
+        return this;
+      }
+      public Builder ClearUnpackedInt64() {
+        PrepareBuilder();
+        result.unpackedInt64_.Clear();
+        return this;
+      }
+      
+      [global::System.CLSCompliant(false)]
+      public pbc::IPopsicleList<uint> UnpackedUint32List {
+        get { return PrepareBuilder().unpackedUint32_; }
+      }
+      public int UnpackedUint32Count {
+        get { return result.UnpackedUint32Count; }
+      }
+      [global::System.CLSCompliant(false)]
+      public uint GetUnpackedUint32(int index) {
+        return result.GetUnpackedUint32(index);
+      }
+      [global::System.CLSCompliant(false)]
+      public Builder SetUnpackedUint32(int index, uint value) {
+        PrepareBuilder();
+        result.unpackedUint32_[index] = value;
+        return this;
+      }
+      [global::System.CLSCompliant(false)]
+      public Builder AddUnpackedUint32(uint value) {
+        PrepareBuilder();
+        result.unpackedUint32_.Add(value);
+        return this;
+      }
+      [global::System.CLSCompliant(false)]
+      public Builder AddRangeUnpackedUint32(scg::IEnumerable<uint> values) {
+        PrepareBuilder();
+        result.unpackedUint32_.Add(values);
+        return this;
+      }
+      public Builder ClearUnpackedUint32() {
+        PrepareBuilder();
+        result.unpackedUint32_.Clear();
+        return this;
+      }
+      
+      [global::System.CLSCompliant(false)]
+      public pbc::IPopsicleList<ulong> UnpackedUint64List {
+        get { return PrepareBuilder().unpackedUint64_; }
+      }
+      public int UnpackedUint64Count {
+        get { return result.UnpackedUint64Count; }
+      }
+      [global::System.CLSCompliant(false)]
+      public ulong GetUnpackedUint64(int index) {
+        return result.GetUnpackedUint64(index);
+      }
+      [global::System.CLSCompliant(false)]
+      public Builder SetUnpackedUint64(int index, ulong value) {
+        PrepareBuilder();
+        result.unpackedUint64_[index] = value;
+        return this;
+      }
+      [global::System.CLSCompliant(false)]
+      public Builder AddUnpackedUint64(ulong value) {
+        PrepareBuilder();
+        result.unpackedUint64_.Add(value);
+        return this;
+      }
+      [global::System.CLSCompliant(false)]
+      public Builder AddRangeUnpackedUint64(scg::IEnumerable<ulong> values) {
+        PrepareBuilder();
+        result.unpackedUint64_.Add(values);
+        return this;
+      }
+      public Builder ClearUnpackedUint64() {
+        PrepareBuilder();
+        result.unpackedUint64_.Clear();
+        return this;
+      }
+      
+      public pbc::IPopsicleList<int> UnpackedSint32List {
+        get { return PrepareBuilder().unpackedSint32_; }
+      }
+      public int UnpackedSint32Count {
+        get { return result.UnpackedSint32Count; }
+      }
+      public int GetUnpackedSint32(int index) {
+        return result.GetUnpackedSint32(index);
+      }
+      public Builder SetUnpackedSint32(int index, int value) {
+        PrepareBuilder();
+        result.unpackedSint32_[index] = value;
+        return this;
+      }
+      public Builder AddUnpackedSint32(int value) {
+        PrepareBuilder();
+        result.unpackedSint32_.Add(value);
+        return this;
+      }
+      public Builder AddRangeUnpackedSint32(scg::IEnumerable<int> values) {
+        PrepareBuilder();
+        result.unpackedSint32_.Add(values);
+        return this;
+      }
+      public Builder ClearUnpackedSint32() {
+        PrepareBuilder();
+        result.unpackedSint32_.Clear();
+        return this;
+      }
+      
+      public pbc::IPopsicleList<long> UnpackedSint64List {
+        get { return PrepareBuilder().unpackedSint64_; }
+      }
+      public int UnpackedSint64Count {
+        get { return result.UnpackedSint64Count; }
+      }
+      public long GetUnpackedSint64(int index) {
+        return result.GetUnpackedSint64(index);
+      }
+      public Builder SetUnpackedSint64(int index, long value) {
+        PrepareBuilder();
+        result.unpackedSint64_[index] = value;
+        return this;
+      }
+      public Builder AddUnpackedSint64(long value) {
+        PrepareBuilder();
+        result.unpackedSint64_.Add(value);
+        return this;
+      }
+      public Builder AddRangeUnpackedSint64(scg::IEnumerable<long> values) {
+        PrepareBuilder();
+        result.unpackedSint64_.Add(values);
+        return this;
+      }
+      public Builder ClearUnpackedSint64() {
+        PrepareBuilder();
+        result.unpackedSint64_.Clear();
+        return this;
+      }
+      
+      [global::System.CLSCompliant(false)]
+      public pbc::IPopsicleList<uint> UnpackedFixed32List {
+        get { return PrepareBuilder().unpackedFixed32_; }
+      }
+      public int UnpackedFixed32Count {
+        get { return result.UnpackedFixed32Count; }
+      }
+      [global::System.CLSCompliant(false)]
+      public uint GetUnpackedFixed32(int index) {
+        return result.GetUnpackedFixed32(index);
+      }
+      [global::System.CLSCompliant(false)]
+      public Builder SetUnpackedFixed32(int index, uint value) {
+        PrepareBuilder();
+        result.unpackedFixed32_[index] = value;
+        return this;
+      }
+      [global::System.CLSCompliant(false)]
+      public Builder AddUnpackedFixed32(uint value) {
+        PrepareBuilder();
+        result.unpackedFixed32_.Add(value);
+        return this;
+      }
+      [global::System.CLSCompliant(false)]
+      public Builder AddRangeUnpackedFixed32(scg::IEnumerable<uint> values) {
+        PrepareBuilder();
+        result.unpackedFixed32_.Add(values);
+        return this;
+      }
+      public Builder ClearUnpackedFixed32() {
+        PrepareBuilder();
+        result.unpackedFixed32_.Clear();
+        return this;
+      }
+      
+      [global::System.CLSCompliant(false)]
+      public pbc::IPopsicleList<ulong> UnpackedFixed64List {
+        get { return PrepareBuilder().unpackedFixed64_; }
+      }
+      public int UnpackedFixed64Count {
+        get { return result.UnpackedFixed64Count; }
+      }
+      [global::System.CLSCompliant(false)]
+      public ulong GetUnpackedFixed64(int index) {
+        return result.GetUnpackedFixed64(index);
+      }
+      [global::System.CLSCompliant(false)]
+      public Builder SetUnpackedFixed64(int index, ulong value) {
+        PrepareBuilder();
+        result.unpackedFixed64_[index] = value;
+        return this;
+      }
+      [global::System.CLSCompliant(false)]
+      public Builder AddUnpackedFixed64(ulong value) {
+        PrepareBuilder();
+        result.unpackedFixed64_.Add(value);
+        return this;
+      }
+      [global::System.CLSCompliant(false)]
+      public Builder AddRangeUnpackedFixed64(scg::IEnumerable<ulong> values) {
+        PrepareBuilder();
+        result.unpackedFixed64_.Add(values);
+        return this;
+      }
+      public Builder ClearUnpackedFixed64() {
+        PrepareBuilder();
+        result.unpackedFixed64_.Clear();
+        return this;
+      }
+      
+      public pbc::IPopsicleList<int> UnpackedSfixed32List {
+        get { return PrepareBuilder().unpackedSfixed32_; }
+      }
+      public int UnpackedSfixed32Count {
+        get { return result.UnpackedSfixed32Count; }
+      }
+      public int GetUnpackedSfixed32(int index) {
+        return result.GetUnpackedSfixed32(index);
+      }
+      public Builder SetUnpackedSfixed32(int index, int value) {
+        PrepareBuilder();
+        result.unpackedSfixed32_[index] = value;
+        return this;
+      }
+      public Builder AddUnpackedSfixed32(int value) {
+        PrepareBuilder();
+        result.unpackedSfixed32_.Add(value);
+        return this;
+      }
+      public Builder AddRangeUnpackedSfixed32(scg::IEnumerable<int> values) {
+        PrepareBuilder();
+        result.unpackedSfixed32_.Add(values);
+        return this;
+      }
+      public Builder ClearUnpackedSfixed32() {
+        PrepareBuilder();
+        result.unpackedSfixed32_.Clear();
+        return this;
+      }
+      
+      public pbc::IPopsicleList<long> UnpackedSfixed64List {
+        get { return PrepareBuilder().unpackedSfixed64_; }
+      }
+      public int UnpackedSfixed64Count {
+        get { return result.UnpackedSfixed64Count; }
+      }
+      public long GetUnpackedSfixed64(int index) {
+        return result.GetUnpackedSfixed64(index);
+      }
+      public Builder SetUnpackedSfixed64(int index, long value) {
+        PrepareBuilder();
+        result.unpackedSfixed64_[index] = value;
+        return this;
+      }
+      public Builder AddUnpackedSfixed64(long value) {
+        PrepareBuilder();
+        result.unpackedSfixed64_.Add(value);
+        return this;
+      }
+      public Builder AddRangeUnpackedSfixed64(scg::IEnumerable<long> values) {
+        PrepareBuilder();
+        result.unpackedSfixed64_.Add(values);
+        return this;
+      }
+      public Builder ClearUnpackedSfixed64() {
+        PrepareBuilder();
+        result.unpackedSfixed64_.Clear();
+        return this;
+      }
+      
+      public pbc::IPopsicleList<float> UnpackedFloatList {
+        get { return PrepareBuilder().unpackedFloat_; }
+      }
+      public int UnpackedFloatCount {
+        get { return result.UnpackedFloatCount; }
+      }
+      public float GetUnpackedFloat(int index) {
+        return result.GetUnpackedFloat(index);
+      }
+      public Builder SetUnpackedFloat(int index, float value) {
+        PrepareBuilder();
+        result.unpackedFloat_[index] = value;
+        return this;
+      }
+      public Builder AddUnpackedFloat(float value) {
+        PrepareBuilder();
+        result.unpackedFloat_.Add(value);
+        return this;
+      }
+      public Builder AddRangeUnpackedFloat(scg::IEnumerable<float> values) {
+        PrepareBuilder();
+        result.unpackedFloat_.Add(values);
+        return this;
+      }
+      public Builder ClearUnpackedFloat() {
+        PrepareBuilder();
+        result.unpackedFloat_.Clear();
+        return this;
+      }
+      
+      public pbc::IPopsicleList<double> UnpackedDoubleList {
+        get { return PrepareBuilder().unpackedDouble_; }
+      }
+      public int UnpackedDoubleCount {
+        get { return result.UnpackedDoubleCount; }
+      }
+      public double GetUnpackedDouble(int index) {
+        return result.GetUnpackedDouble(index);
+      }
+      public Builder SetUnpackedDouble(int index, double value) {
+        PrepareBuilder();
+        result.unpackedDouble_[index] = value;
+        return this;
+      }
+      public Builder AddUnpackedDouble(double value) {
+        PrepareBuilder();
+        result.unpackedDouble_.Add(value);
+        return this;
+      }
+      public Builder AddRangeUnpackedDouble(scg::IEnumerable<double> values) {
+        PrepareBuilder();
+        result.unpackedDouble_.Add(values);
+        return this;
+      }
+      public Builder ClearUnpackedDouble() {
+        PrepareBuilder();
+        result.unpackedDouble_.Clear();
+        return this;
+      }
+      
+      public pbc::IPopsicleList<bool> UnpackedBoolList {
+        get { return PrepareBuilder().unpackedBool_; }
+      }
+      public int UnpackedBoolCount {
+        get { return result.UnpackedBoolCount; }
+      }
+      public bool GetUnpackedBool(int index) {
+        return result.GetUnpackedBool(index);
+      }
+      public Builder SetUnpackedBool(int index, bool value) {
+        PrepareBuilder();
+        result.unpackedBool_[index] = value;
+        return this;
+      }
+      public Builder AddUnpackedBool(bool value) {
+        PrepareBuilder();
+        result.unpackedBool_.Add(value);
+        return this;
+      }
+      public Builder AddRangeUnpackedBool(scg::IEnumerable<bool> values) {
+        PrepareBuilder();
+        result.unpackedBool_.Add(values);
+        return this;
+      }
+      public Builder ClearUnpackedBool() {
+        PrepareBuilder();
+        result.unpackedBool_.Clear();
+        return this;
+      }
+      
+      public pbc::IPopsicleList<global::Google.ProtocolBuffers.TestProtos.UnpackedTypesForeignEnumLite> UnpackedEnumList {
+        get { return PrepareBuilder().unpackedEnum_; }
+      }
+      public int UnpackedEnumCount {
+        get { return result.UnpackedEnumCount; }
+      }
+      public global::Google.ProtocolBuffers.TestProtos.UnpackedTypesForeignEnumLite GetUnpackedEnum(int index) {
+        return result.GetUnpackedEnum(index);
+      }
+      public Builder SetUnpackedEnum(int index, global::Google.ProtocolBuffers.TestProtos.UnpackedTypesForeignEnumLite value) {
+        PrepareBuilder();
+        result.unpackedEnum_[index] = value;
+        return this;
+      }
+      public Builder AddUnpackedEnum(global::Google.ProtocolBuffers.TestProtos.UnpackedTypesForeignEnumLite value) {
+        PrepareBuilder();
+        result.unpackedEnum_.Add(value);
+        return this;
+      }
+      public Builder AddRangeUnpackedEnum(scg::IEnumerable<global::Google.ProtocolBuffers.TestProtos.UnpackedTypesForeignEnumLite> values) {
+        PrepareBuilder();
+        result.unpackedEnum_.Add(values);
+        return this;
+      }
+      public Builder ClearUnpackedEnum() {
+        PrepareBuilder();
+        result.unpackedEnum_.Clear();
+        return this;
+      }
+    }
+    static TestUnpackedTypesLite() {
+      object.ReferenceEquals(global::Google.ProtocolBuffers.TestProtos.UnitTestExtrasLiteProtoFile.Descriptor, null);
+    }
+  }
+  
   #endregion
   
 }