// Generated by ProtoGen, Version=2.4.1.521, Culture=neutral, PublicKeyToken=17b3b1f090c3ea48.  DO NOT EDIT!
#pragma warning disable 1591, 0612, 3021
#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()]
  public static partial class UnitTestGoogleSpeedProtoFile {
  
    #region Extension registration
    public static void RegisterAllExtensions(pb::ExtensionRegistry registry) {
    }
    #endregion
    #region Static variables
    internal static pbd::MessageDescriptor internal__static_unittest_google_speed_SpeedMessage1__Descriptor;
    internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.SpeedMessage1, global::Google.ProtocolBuffers.TestProtos.SpeedMessage1.Builder> internal__static_unittest_google_speed_SpeedMessage1__FieldAccessorTable;
    internal static pbd::MessageDescriptor internal__static_unittest_google_speed_SpeedMessage1SubMessage__Descriptor;
    internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.SpeedMessage1SubMessage, global::Google.ProtocolBuffers.TestProtos.SpeedMessage1SubMessage.Builder> internal__static_unittest_google_speed_SpeedMessage1SubMessage__FieldAccessorTable;
    internal static pbd::MessageDescriptor internal__static_unittest_google_speed_SpeedMessage2__Descriptor;
    internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.SpeedMessage2, global::Google.ProtocolBuffers.TestProtos.SpeedMessage2.Builder> internal__static_unittest_google_speed_SpeedMessage2__FieldAccessorTable;
    internal static pbd::MessageDescriptor internal__static_unittest_google_speed_SpeedMessage2_Group1__Descriptor;
    internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.SpeedMessage2.Types.Group1, global::Google.ProtocolBuffers.TestProtos.SpeedMessage2.Types.Group1.Builder> internal__static_unittest_google_speed_SpeedMessage2_Group1__FieldAccessorTable;
    internal static pbd::MessageDescriptor internal__static_unittest_google_speed_SpeedMessage2GroupedMessage__Descriptor;
    internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.SpeedMessage2GroupedMessage, global::Google.ProtocolBuffers.TestProtos.SpeedMessage2GroupedMessage.Builder> internal__static_unittest_google_speed_SpeedMessage2GroupedMessage__FieldAccessorTable;
    #endregion
    #region Descriptor
    public static pbd::FileDescriptor Descriptor {
      get { return descriptor; }
    }
    private static pbd::FileDescriptor descriptor;
    
    static UnitTestGoogleSpeedProtoFile() {
      byte[] descriptorData = global::System.Convert.FromBase64String(
          string.Concat(
            "Ch5nb29nbGUvdGVzdC9nb29nbGVfc3BlZWQucHJvdG8SFXVuaXR0ZXN0X2dv", 
            "b2dsZV9zcGVlZBokZ29vZ2xlL3Byb3RvYnVmL2NzaGFycF9vcHRpb25zLnBy", 
            "b3RvIoMHCg1TcGVlZE1lc3NhZ2UxEg4KBmZpZWxkMRgBIAIoCRIOCgZmaWVs", 
            "ZDkYCSABKAkSDwoHZmllbGQxOBgSIAEoCRIWCgdmaWVsZDgwGFAgASgIOgVm", 
            "YWxzZRIVCgdmaWVsZDgxGFEgASgIOgR0cnVlEg4KBmZpZWxkMhgCIAIoBRIO", 
            "CgZmaWVsZDMYAyACKAUSEQoIZmllbGQyODAYmAIgASgFEhEKBmZpZWxkNhgG", 
            "IAEoBToBMBIPCgdmaWVsZDIyGBYgASgDEg4KBmZpZWxkNBgEIAEoCRIOCgZm", 
            "aWVsZDUYBSADKAYSFgoHZmllbGQ1ORg7IAEoCDoFZmFsc2USDgoGZmllbGQ3", 
            "GAcgASgJEg8KB2ZpZWxkMTYYECABKAUSFAoIZmllbGQxMzAYggEgASgFOgEw", 
            "EhUKB2ZpZWxkMTIYDCABKAg6BHRydWUSFQoHZmllbGQxNxgRIAEoCDoEdHJ1", 
            "ZRIVCgdmaWVsZDEzGA0gASgIOgR0cnVlEhUKB2ZpZWxkMTQYDiABKAg6BHRy", 
            "dWUSEwoIZmllbGQxMDQYaCABKAU6ATASEwoIZmllbGQxMDAYZCABKAU6ATAS", 
            "EwoIZmllbGQxMDEYZSABKAU6ATASEAoIZmllbGQxMDIYZiABKAkSEAoIZmll", 
            "bGQxMDMYZyABKAkSEgoHZmllbGQyORgdIAEoBToBMBIWCgdmaWVsZDMwGB4g", 
            "ASgIOgVmYWxzZRITCgdmaWVsZDYwGDwgASgFOgItMRIVCghmaWVsZDI3MRiP", 
            "AiABKAU6Ai0xEhUKCGZpZWxkMjcyGJACIAEoBToCLTESEQoIZmllbGQxNTAY", 
            "lgEgASgFEhIKB2ZpZWxkMjMYFyABKAU6ATASFgoHZmllbGQyNBgYIAEoCDoF", 
            "ZmFsc2USEgoHZmllbGQyNRgZIAEoBToBMBI/CgdmaWVsZDE1GA8gASgLMi4u", 
            "dW5pdHRlc3RfZ29vZ2xlX3NwZWVkLlNwZWVkTWVzc2FnZTFTdWJNZXNzYWdl", 
            "Eg8KB2ZpZWxkNzgYTiABKAgSEgoHZmllbGQ2NxhDIAEoBToBMBIPCgdmaWVs", 
            "ZDY4GEQgASgFEhQKCGZpZWxkMTI4GIABIAEoBToBMBIoCghmaWVsZDEyORiB", 
            "ASABKAk6FXh4eHh4eHh4eHh4eHh4eHh4eHh4eBIUCghmaWVsZDEzMRiDASAB", 
            "KAU6ATAiogMKF1NwZWVkTWVzc2FnZTFTdWJNZXNzYWdlEhEKBmZpZWxkMRgB", 
            "IAEoBToBMBIRCgZmaWVsZDIYAiABKAU6ATASEQoGZmllbGQzGAMgASgFOgEw", 
            "Eg8KB2ZpZWxkMTUYDyABKAkSFQoHZmllbGQxMhgMIAEoCDoEdHJ1ZRIPCgdm", 
            "aWVsZDEzGA0gASgDEg8KB2ZpZWxkMTQYDiABKAMSDwoHZmllbGQxNhgQIAEo", 
            "BRISCgdmaWVsZDE5GBMgASgFOgEyEhUKB2ZpZWxkMjAYFCABKAg6BHRydWUS", 
            "FQoHZmllbGQyOBgcIAEoCDoEdHJ1ZRIPCgdmaWVsZDIxGBUgASgGEg8KB2Zp", 
            "ZWxkMjIYFiABKAUSFgoHZmllbGQyMxgXIAEoCDoFZmFsc2USGAoIZmllbGQy", 
            "MDYYzgEgASgIOgVmYWxzZRIRCghmaWVsZDIwMxjLASABKAcSEQoIZmllbGQy", 
            "MDQYzAEgASgFEhEKCGZpZWxkMjA1GM0BIAEoCRIRCghmaWVsZDIwNxjPASAB", 
            "KAQSEQoIZmllbGQzMDAYrAIgASgEIuAHCg1TcGVlZE1lc3NhZ2UyEg4KBmZp", 
            "ZWxkMRgBIAEoCRIOCgZmaWVsZDMYAyABKAMSDgoGZmllbGQ0GAQgASgDEg8K", 
            "B2ZpZWxkMzAYHiABKAMSFgoHZmllbGQ3NRhLIAEoCDoFZmFsc2USDgoGZmll", 
            "bGQ2GAYgASgJEg4KBmZpZWxkMhgCIAEoDBISCgdmaWVsZDIxGBUgASgFOgEw", 
            "Eg8KB2ZpZWxkNzEYRyABKAUSDwoHZmllbGQyNRgZIAEoAhITCghmaWVsZDEw", 
            "ORhtIAEoBToBMBIUCghmaWVsZDIxMBjSASABKAU6ATASFAoIZmllbGQyMTEY", 
            "0wEgASgFOgEwEhQKCGZpZWxkMjEyGNQBIAEoBToBMBIUCghmaWVsZDIxMxjV", 
            "ASABKAU6ATASFAoIZmllbGQyMTYY2AEgASgFOgEwEhQKCGZpZWxkMjE3GNkB", 
            "IAEoBToBMBIUCghmaWVsZDIxOBjaASABKAU6ATASFAoIZmllbGQyMjAY3AEg", 
            "ASgFOgEwEhQKCGZpZWxkMjIxGN0BIAEoBToBMBIUCghmaWVsZDIyMhjeASAB", 
            "KAI6ATASDwoHZmllbGQ2Mxg/IAEoBRI7CgZncm91cDEYCiADKAoyKy51bml0", 
            "dGVzdF9nb29nbGVfc3BlZWQuU3BlZWRNZXNzYWdlMi5Hcm91cDESEQoIZmll", 
            "bGQxMjgYgAEgAygJEhEKCGZpZWxkMTMxGIMBIAEoAxIQCghmaWVsZDEyNxh/", 
            "IAMoCRIRCghmaWVsZDEyORiBASABKAUSEQoIZmllbGQxMzAYggEgAygDEhgK", 
            "CGZpZWxkMjA1GM0BIAEoCDoFZmFsc2USGAoIZmllbGQyMDYYzgEgASgIOgVm", 
            "YWxzZRrOAgoGR3JvdXAxEg8KB2ZpZWxkMTEYCyACKAISDwoHZmllbGQyNhga", 
            "IAEoAhIPCgdmaWVsZDEyGAwgASgJEg8KB2ZpZWxkMTMYDSABKAkSDwoHZmll", 
            "bGQxNBgOIAMoCRIPCgdmaWVsZDE1GA8gAigEEg4KBmZpZWxkNRgFIAEoBRIP", 
            "CgdmaWVsZDI3GBsgASgJEg8KB2ZpZWxkMjgYHCABKAUSDwoHZmllbGQyORgd", 
            "IAEoCRIPCgdmaWVsZDE2GBAgASgJEg8KB2ZpZWxkMjIYFiADKAkSDwoHZmll", 
            "bGQ3MxhJIAMoBRISCgdmaWVsZDIwGBQgASgFOgEwEg8KB2ZpZWxkMjQYGCAB", 
            "KAkSQwoHZmllbGQzMRgfIAEoCzIyLnVuaXR0ZXN0X2dvb2dsZV9zcGVlZC5T", 
            "cGVlZE1lc3NhZ2UyR3JvdXBlZE1lc3NhZ2Ui3wEKG1NwZWVkTWVzc2FnZTJH", 
            "cm91cGVkTWVzc2FnZRIOCgZmaWVsZDEYASABKAISDgoGZmllbGQyGAIgASgC", 
            "EhEKBmZpZWxkMxgDIAEoAjoBMBIOCgZmaWVsZDQYBCABKAgSDgoGZmllbGQ1", 
            "GAUgASgIEhQKBmZpZWxkNhgGIAEoCDoEdHJ1ZRIVCgZmaWVsZDcYByABKAg6", 
            "BWZhbHNlEg4KBmZpZWxkOBgIIAEoAhIOCgZmaWVsZDkYCSABKAgSDwoHZmll", 
            "bGQxMBgKIAEoAhIPCgdmaWVsZDExGAsgASgDQlNCC0dvb2dsZVNwZWVkSAHC", 
            "PkEKIUdvb2dsZS5Qcm90b2NvbEJ1ZmZlcnMuVGVzdFByb3RvcxIcVW5pdFRl", 
          "c3RHb29nbGVTcGVlZFByb3RvRmlsZQ=="));
      pbd::FileDescriptor.InternalDescriptorAssigner assigner = delegate(pbd::FileDescriptor root) {
        descriptor = root;
        internal__static_unittest_google_speed_SpeedMessage1__Descriptor = Descriptor.MessageTypes[0];
        internal__static_unittest_google_speed_SpeedMessage1__FieldAccessorTable = 
            new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.SpeedMessage1, global::Google.ProtocolBuffers.TestProtos.SpeedMessage1.Builder>(internal__static_unittest_google_speed_SpeedMessage1__Descriptor,
                new string[] { "Field1", "Field9", "Field18", "Field80", "Field81", "Field2", "Field3", "Field280", "Field6", "Field22", "Field4", "Field5", "Field59", "Field7", "Field16", "Field130", "Field12", "Field17", "Field13", "Field14", "Field104", "Field100", "Field101", "Field102", "Field103", "Field29", "Field30", "Field60", "Field271", "Field272", "Field150", "Field23", "Field24", "Field25", "Field15", "Field78", "Field67", "Field68", "Field128", "Field129", "Field131", });
        internal__static_unittest_google_speed_SpeedMessage1SubMessage__Descriptor = Descriptor.MessageTypes[1];
        internal__static_unittest_google_speed_SpeedMessage1SubMessage__FieldAccessorTable = 
            new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.SpeedMessage1SubMessage, global::Google.ProtocolBuffers.TestProtos.SpeedMessage1SubMessage.Builder>(internal__static_unittest_google_speed_SpeedMessage1SubMessage__Descriptor,
                new string[] { "Field1", "Field2", "Field3", "Field15", "Field12", "Field13", "Field14", "Field16", "Field19", "Field20", "Field28", "Field21", "Field22", "Field23", "Field206", "Field203", "Field204", "Field205", "Field207", "Field300", });
        internal__static_unittest_google_speed_SpeedMessage2__Descriptor = Descriptor.MessageTypes[2];
        internal__static_unittest_google_speed_SpeedMessage2__FieldAccessorTable = 
            new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.SpeedMessage2, global::Google.ProtocolBuffers.TestProtos.SpeedMessage2.Builder>(internal__static_unittest_google_speed_SpeedMessage2__Descriptor,
                new string[] { "Field1", "Field3", "Field4", "Field30", "Field75", "Field6", "Field2", "Field21", "Field71", "Field25", "Field109", "Field210", "Field211", "Field212", "Field213", "Field216", "Field217", "Field218", "Field220", "Field221", "Field222", "Field63", "Group1", "Field128", "Field131", "Field127", "Field129", "Field130", "Field205", "Field206", });
        internal__static_unittest_google_speed_SpeedMessage2_Group1__Descriptor = internal__static_unittest_google_speed_SpeedMessage2__Descriptor.NestedTypes[0];
        internal__static_unittest_google_speed_SpeedMessage2_Group1__FieldAccessorTable = 
            new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.SpeedMessage2.Types.Group1, global::Google.ProtocolBuffers.TestProtos.SpeedMessage2.Types.Group1.Builder>(internal__static_unittest_google_speed_SpeedMessage2_Group1__Descriptor,
                new string[] { "Field11", "Field26", "Field12", "Field13", "Field14", "Field15", "Field5", "Field27", "Field28", "Field29", "Field16", "Field22", "Field73", "Field20", "Field24", "Field31", });
        internal__static_unittest_google_speed_SpeedMessage2GroupedMessage__Descriptor = Descriptor.MessageTypes[3];
        internal__static_unittest_google_speed_SpeedMessage2GroupedMessage__FieldAccessorTable = 
            new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.TestProtos.SpeedMessage2GroupedMessage, global::Google.ProtocolBuffers.TestProtos.SpeedMessage2GroupedMessage.Builder>(internal__static_unittest_google_speed_SpeedMessage2GroupedMessage__Descriptor,
                new string[] { "Field1", "Field2", "Field3", "Field4", "Field5", "Field6", "Field7", "Field8", "Field9", "Field10", "Field11", });
        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 Messages
  [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
  public sealed partial class SpeedMessage1 : pb::GeneratedMessage<SpeedMessage1, SpeedMessage1.Builder> {
    private SpeedMessage1() { }
    private static readonly SpeedMessage1 defaultInstance = new SpeedMessage1().MakeReadOnly();
    private static readonly string[] _speedMessage1FieldNames = new string[] { "field1", "field100", "field101", "field102", "field103", "field104", "field12", "field128", "field129", "field13", "field130", "field131", "field14", "field15", "field150", "field16", "field17", "field18", "field2", "field22", "field23", "field24", "field25", "field271", "field272", "field280", "field29", "field3", "field30", "field4", "field5", "field59", "field6", "field60", "field67", "field68", "field7", "field78", "field80", "field81", "field9" };
    private static readonly uint[] _speedMessage1FieldTags = new uint[] { 10, 800, 808, 818, 826, 832, 96, 1024, 1034, 104, 1040, 1048, 112, 122, 1200, 128, 136, 146, 16, 176, 184, 192, 200, 2168, 2176, 2240, 232, 24, 240, 34, 41, 472, 48, 480, 536, 544, 58, 624, 640, 648, 74 };
    public static SpeedMessage1 DefaultInstance {
      get { return defaultInstance; }
    }
    
    public override SpeedMessage1 DefaultInstanceForType {
      get { return DefaultInstance; }
    }
    
    protected override SpeedMessage1 ThisMessage {
      get { return this; }
    }
    
    public static pbd::MessageDescriptor Descriptor {
      get { return global::Google.ProtocolBuffers.TestProtos.UnitTestGoogleSpeedProtoFile.internal__static_unittest_google_speed_SpeedMessage1__Descriptor; }
    }
    
    protected override pb::FieldAccess.FieldAccessorTable<SpeedMessage1, SpeedMessage1.Builder> InternalFieldAccessors {
      get { return global::Google.ProtocolBuffers.TestProtos.UnitTestGoogleSpeedProtoFile.internal__static_unittest_google_speed_SpeedMessage1__FieldAccessorTable; }
    }
    
    public const int Field1FieldNumber = 1;
    private bool hasField1;
    private string field1_ = "";
    public bool HasField1 {
      get { return hasField1; }
    }
    public string Field1 {
      get { return field1_; }
    }
    
    public const int Field9FieldNumber = 9;
    private bool hasField9;
    private string field9_ = "";
    public bool HasField9 {
      get { return hasField9; }
    }
    public string Field9 {
      get { return field9_; }
    }
    
    public const int Field18FieldNumber = 18;
    private bool hasField18;
    private string field18_ = "";
    public bool HasField18 {
      get { return hasField18; }
    }
    public string Field18 {
      get { return field18_; }
    }
    
    public const int Field80FieldNumber = 80;
    private bool hasField80;
    private bool field80_;
    public bool HasField80 {
      get { return hasField80; }
    }
    public bool Field80 {
      get { return field80_; }
    }
    
    public const int Field81FieldNumber = 81;
    private bool hasField81;
    private bool field81_ = true;
    public bool HasField81 {
      get { return hasField81; }
    }
    public bool Field81 {
      get { return field81_; }
    }
    
    public const int Field2FieldNumber = 2;
    private bool hasField2;
    private int field2_;
    public bool HasField2 {
      get { return hasField2; }
    }
    public int Field2 {
      get { return field2_; }
    }
    
    public const int Field3FieldNumber = 3;
    private bool hasField3;
    private int field3_;
    public bool HasField3 {
      get { return hasField3; }
    }
    public int Field3 {
      get { return field3_; }
    }
    
    public const int Field280FieldNumber = 280;
    private bool hasField280;
    private int field280_;
    public bool HasField280 {
      get { return hasField280; }
    }
    public int Field280 {
      get { return field280_; }
    }
    
    public const int Field6FieldNumber = 6;
    private bool hasField6;
    private int field6_;
    public bool HasField6 {
      get { return hasField6; }
    }
    public int Field6 {
      get { return field6_; }
    }
    
    public const int Field22FieldNumber = 22;
    private bool hasField22;
    private long field22_;
    public bool HasField22 {
      get { return hasField22; }
    }
    public long Field22 {
      get { return field22_; }
    }
    
    public const int Field4FieldNumber = 4;
    private bool hasField4;
    private string field4_ = "";
    public bool HasField4 {
      get { return hasField4; }
    }
    public string Field4 {
      get { return field4_; }
    }
    
    public const int Field5FieldNumber = 5;
    private pbc::PopsicleList<ulong> field5_ = new pbc::PopsicleList<ulong>();
    [global::System.CLSCompliant(false)]
    public scg::IList<ulong> Field5List {
      get { return pbc::Lists.AsReadOnly(field5_); }
    }
    public int Field5Count {
      get { return field5_.Count; }
    }
    [global::System.CLSCompliant(false)]
    public ulong GetField5(int index) {
      return field5_[index];
    }
    
    public const int Field59FieldNumber = 59;
    private bool hasField59;
    private bool field59_;
    public bool HasField59 {
      get { return hasField59; }
    }
    public bool Field59 {
      get { return field59_; }
    }
    
    public const int Field7FieldNumber = 7;
    private bool hasField7;
    private string field7_ = "";
    public bool HasField7 {
      get { return hasField7; }
    }
    public string Field7 {
      get { return field7_; }
    }
    
    public const int Field16FieldNumber = 16;
    private bool hasField16;
    private int field16_;
    public bool HasField16 {
      get { return hasField16; }
    }
    public int Field16 {
      get { return field16_; }
    }
    
    public const int Field130FieldNumber = 130;
    private bool hasField130;
    private int field130_;
    public bool HasField130 {
      get { return hasField130; }
    }
    public int Field130 {
      get { return field130_; }
    }
    
    public const int Field12FieldNumber = 12;
    private bool hasField12;
    private bool field12_ = true;
    public bool HasField12 {
      get { return hasField12; }
    }
    public bool Field12 {
      get { return field12_; }
    }
    
    public const int Field17FieldNumber = 17;
    private bool hasField17;
    private bool field17_ = true;
    public bool HasField17 {
      get { return hasField17; }
    }
    public bool Field17 {
      get { return field17_; }
    }
    
    public const int Field13FieldNumber = 13;
    private bool hasField13;
    private bool field13_ = true;
    public bool HasField13 {
      get { return hasField13; }
    }
    public bool Field13 {
      get { return field13_; }
    }
    
    public const int Field14FieldNumber = 14;
    private bool hasField14;
    private bool field14_ = true;
    public bool HasField14 {
      get { return hasField14; }
    }
    public bool Field14 {
      get { return field14_; }
    }
    
    public const int Field104FieldNumber = 104;
    private bool hasField104;
    private int field104_;
    public bool HasField104 {
      get { return hasField104; }
    }
    public int Field104 {
      get { return field104_; }
    }
    
    public const int Field100FieldNumber = 100;
    private bool hasField100;
    private int field100_;
    public bool HasField100 {
      get { return hasField100; }
    }
    public int Field100 {
      get { return field100_; }
    }
    
    public const int Field101FieldNumber = 101;
    private bool hasField101;
    private int field101_;
    public bool HasField101 {
      get { return hasField101; }
    }
    public int Field101 {
      get { return field101_; }
    }
    
    public const int Field102FieldNumber = 102;
    private bool hasField102;
    private string field102_ = "";
    public bool HasField102 {
      get { return hasField102; }
    }
    public string Field102 {
      get { return field102_; }
    }
    
    public const int Field103FieldNumber = 103;
    private bool hasField103;
    private string field103_ = "";
    public bool HasField103 {
      get { return hasField103; }
    }
    public string Field103 {
      get { return field103_; }
    }
    
    public const int Field29FieldNumber = 29;
    private bool hasField29;
    private int field29_;
    public bool HasField29 {
      get { return hasField29; }
    }
    public int Field29 {
      get { return field29_; }
    }
    
    public const int Field30FieldNumber = 30;
    private bool hasField30;
    private bool field30_;
    public bool HasField30 {
      get { return hasField30; }
    }
    public bool Field30 {
      get { return field30_; }
    }
    
    public const int Field60FieldNumber = 60;
    private bool hasField60;
    private int field60_ = -1;
    public bool HasField60 {
      get { return hasField60; }
    }
    public int Field60 {
      get { return field60_; }
    }
    
    public const int Field271FieldNumber = 271;
    private bool hasField271;
    private int field271_ = -1;
    public bool HasField271 {
      get { return hasField271; }
    }
    public int Field271 {
      get { return field271_; }
    }
    
    public const int Field272FieldNumber = 272;
    private bool hasField272;
    private int field272_ = -1;
    public bool HasField272 {
      get { return hasField272; }
    }
    public int Field272 {
      get { return field272_; }
    }
    
    public const int Field150FieldNumber = 150;
    private bool hasField150;
    private int field150_;
    public bool HasField150 {
      get { return hasField150; }
    }
    public int Field150 {
      get { return field150_; }
    }
    
    public const int Field23FieldNumber = 23;
    private bool hasField23;
    private int field23_;
    public bool HasField23 {
      get { return hasField23; }
    }
    public int Field23 {
      get { return field23_; }
    }
    
    public const int Field24FieldNumber = 24;
    private bool hasField24;
    private bool field24_;
    public bool HasField24 {
      get { return hasField24; }
    }
    public bool Field24 {
      get { return field24_; }
    }
    
    public const int Field25FieldNumber = 25;
    private bool hasField25;
    private int field25_;
    public bool HasField25 {
      get { return hasField25; }
    }
    public int Field25 {
      get { return field25_; }
    }
    
    public const int Field15FieldNumber = 15;
    private bool hasField15;
    private global::Google.ProtocolBuffers.TestProtos.SpeedMessage1SubMessage field15_;
    public bool HasField15 {
      get { return hasField15; }
    }
    public global::Google.ProtocolBuffers.TestProtos.SpeedMessage1SubMessage Field15 {
      get { return field15_ ?? global::Google.ProtocolBuffers.TestProtos.SpeedMessage1SubMessage.DefaultInstance; }
    }
    
    public const int Field78FieldNumber = 78;
    private bool hasField78;
    private bool field78_;
    public bool HasField78 {
      get { return hasField78; }
    }
    public bool Field78 {
      get { return field78_; }
    }
    
    public const int Field67FieldNumber = 67;
    private bool hasField67;
    private int field67_;
    public bool HasField67 {
      get { return hasField67; }
    }
    public int Field67 {
      get { return field67_; }
    }
    
    public const int Field68FieldNumber = 68;
    private bool hasField68;
    private int field68_;
    public bool HasField68 {
      get { return hasField68; }
    }
    public int Field68 {
      get { return field68_; }
    }
    
    public const int Field128FieldNumber = 128;
    private bool hasField128;
    private int field128_;
    public bool HasField128 {
      get { return hasField128; }
    }
    public int Field128 {
      get { return field128_; }
    }
    
    public const int Field129FieldNumber = 129;
    private bool hasField129;
    private string field129_ = "xxxxxxxxxxxxxxxxxxxxx";
    public bool HasField129 {
      get { return hasField129; }
    }
    public string Field129 {
      get { return field129_; }
    }
    
    public const int Field131FieldNumber = 131;
    private bool hasField131;
    private int field131_;
    public bool HasField131 {
      get { return hasField131; }
    }
    public int Field131 {
      get { return field131_; }
    }
    
    public override bool IsInitialized {
      get {
        if (!hasField1) return false;
        if (!hasField2) return false;
        if (!hasField3) return false;
        return true;
      }
    }
    
    public override void WriteTo(pb::ICodedOutputStream output) {
      int size = SerializedSize;
      string[] field_names = _speedMessage1FieldNames;
      if (hasField1) {
        output.WriteString(1, field_names[0], Field1);
      }
      if (hasField2) {
        output.WriteInt32(2, field_names[18], Field2);
      }
      if (hasField3) {
        output.WriteInt32(3, field_names[27], Field3);
      }
      if (hasField4) {
        output.WriteString(4, field_names[29], Field4);
      }
      if (field5_.Count > 0) {
        output.WriteFixed64Array(5, field_names[30], field5_);
      }
      if (hasField6) {
        output.WriteInt32(6, field_names[32], Field6);
      }
      if (hasField7) {
        output.WriteString(7, field_names[36], Field7);
      }
      if (hasField9) {
        output.WriteString(9, field_names[40], Field9);
      }
      if (hasField12) {
        output.WriteBool(12, field_names[6], Field12);
      }
      if (hasField13) {
        output.WriteBool(13, field_names[9], Field13);
      }
      if (hasField14) {
        output.WriteBool(14, field_names[12], Field14);
      }
      if (hasField15) {
        output.WriteMessage(15, field_names[13], Field15);
      }
      if (hasField16) {
        output.WriteInt32(16, field_names[15], Field16);
      }
      if (hasField17) {
        output.WriteBool(17, field_names[16], Field17);
      }
      if (hasField18) {
        output.WriteString(18, field_names[17], Field18);
      }
      if (hasField22) {
        output.WriteInt64(22, field_names[19], Field22);
      }
      if (hasField23) {
        output.WriteInt32(23, field_names[20], Field23);
      }
      if (hasField24) {
        output.WriteBool(24, field_names[21], Field24);
      }
      if (hasField25) {
        output.WriteInt32(25, field_names[22], Field25);
      }
      if (hasField29) {
        output.WriteInt32(29, field_names[26], Field29);
      }
      if (hasField30) {
        output.WriteBool(30, field_names[28], Field30);
      }
      if (hasField59) {
        output.WriteBool(59, field_names[31], Field59);
      }
      if (hasField60) {
        output.WriteInt32(60, field_names[33], Field60);
      }
      if (hasField67) {
        output.WriteInt32(67, field_names[34], Field67);
      }
      if (hasField68) {
        output.WriteInt32(68, field_names[35], Field68);
      }
      if (hasField78) {
        output.WriteBool(78, field_names[37], Field78);
      }
      if (hasField80) {
        output.WriteBool(80, field_names[38], Field80);
      }
      if (hasField81) {
        output.WriteBool(81, field_names[39], Field81);
      }
      if (hasField100) {
        output.WriteInt32(100, field_names[1], Field100);
      }
      if (hasField101) {
        output.WriteInt32(101, field_names[2], Field101);
      }
      if (hasField102) {
        output.WriteString(102, field_names[3], Field102);
      }
      if (hasField103) {
        output.WriteString(103, field_names[4], Field103);
      }
      if (hasField104) {
        output.WriteInt32(104, field_names[5], Field104);
      }
      if (hasField128) {
        output.WriteInt32(128, field_names[7], Field128);
      }
      if (hasField129) {
        output.WriteString(129, field_names[8], Field129);
      }
      if (hasField130) {
        output.WriteInt32(130, field_names[10], Field130);
      }
      if (hasField131) {
        output.WriteInt32(131, field_names[11], Field131);
      }
      if (hasField150) {
        output.WriteInt32(150, field_names[14], Field150);
      }
      if (hasField271) {
        output.WriteInt32(271, field_names[23], Field271);
      }
      if (hasField272) {
        output.WriteInt32(272, field_names[24], Field272);
      }
      if (hasField280) {
        output.WriteInt32(280, field_names[25], Field280);
      }
      UnknownFields.WriteTo(output);
    }
    
    private int memoizedSerializedSize = -1;
    public override int SerializedSize {
      get {
        int size = memoizedSerializedSize;
        if (size != -1) return size;
        
        size = 0;
        if (hasField1) {
          size += pb::CodedOutputStream.ComputeStringSize(1, Field1);
        }
        if (hasField9) {
          size += pb::CodedOutputStream.ComputeStringSize(9, Field9);
        }
        if (hasField18) {
          size += pb::CodedOutputStream.ComputeStringSize(18, Field18);
        }
        if (hasField80) {
          size += pb::CodedOutputStream.ComputeBoolSize(80, Field80);
        }
        if (hasField81) {
          size += pb::CodedOutputStream.ComputeBoolSize(81, Field81);
        }
        if (hasField2) {
          size += pb::CodedOutputStream.ComputeInt32Size(2, Field2);
        }
        if (hasField3) {
          size += pb::CodedOutputStream.ComputeInt32Size(3, Field3);
        }
        if (hasField280) {
          size += pb::CodedOutputStream.ComputeInt32Size(280, Field280);
        }
        if (hasField6) {
          size += pb::CodedOutputStream.ComputeInt32Size(6, Field6);
        }
        if (hasField22) {
          size += pb::CodedOutputStream.ComputeInt64Size(22, Field22);
        }
        if (hasField4) {
          size += pb::CodedOutputStream.ComputeStringSize(4, Field4);
        }
        {
          int dataSize = 0;
          dataSize = 8 * field5_.Count;
          size += dataSize;
          size += 1 * field5_.Count;
        }
        if (hasField59) {
          size += pb::CodedOutputStream.ComputeBoolSize(59, Field59);
        }
        if (hasField7) {
          size += pb::CodedOutputStream.ComputeStringSize(7, Field7);
        }
        if (hasField16) {
          size += pb::CodedOutputStream.ComputeInt32Size(16, Field16);
        }
        if (hasField130) {
          size += pb::CodedOutputStream.ComputeInt32Size(130, Field130);
        }
        if (hasField12) {
          size += pb::CodedOutputStream.ComputeBoolSize(12, Field12);
        }
        if (hasField17) {
          size += pb::CodedOutputStream.ComputeBoolSize(17, Field17);
        }
        if (hasField13) {
          size += pb::CodedOutputStream.ComputeBoolSize(13, Field13);
        }
        if (hasField14) {
          size += pb::CodedOutputStream.ComputeBoolSize(14, Field14);
        }
        if (hasField104) {
          size += pb::CodedOutputStream.ComputeInt32Size(104, Field104);
        }
        if (hasField100) {
          size += pb::CodedOutputStream.ComputeInt32Size(100, Field100);
        }
        if (hasField101) {
          size += pb::CodedOutputStream.ComputeInt32Size(101, Field101);
        }
        if (hasField102) {
          size += pb::CodedOutputStream.ComputeStringSize(102, Field102);
        }
        if (hasField103) {
          size += pb::CodedOutputStream.ComputeStringSize(103, Field103);
        }
        if (hasField29) {
          size += pb::CodedOutputStream.ComputeInt32Size(29, Field29);
        }
        if (hasField30) {
          size += pb::CodedOutputStream.ComputeBoolSize(30, Field30);
        }
        if (hasField60) {
          size += pb::CodedOutputStream.ComputeInt32Size(60, Field60);
        }
        if (hasField271) {
          size += pb::CodedOutputStream.ComputeInt32Size(271, Field271);
        }
        if (hasField272) {
          size += pb::CodedOutputStream.ComputeInt32Size(272, Field272);
        }
        if (hasField150) {
          size += pb::CodedOutputStream.ComputeInt32Size(150, Field150);
        }
        if (hasField23) {
          size += pb::CodedOutputStream.ComputeInt32Size(23, Field23);
        }
        if (hasField24) {
          size += pb::CodedOutputStream.ComputeBoolSize(24, Field24);
        }
        if (hasField25) {
          size += pb::CodedOutputStream.ComputeInt32Size(25, Field25);
        }
        if (hasField15) {
          size += pb::CodedOutputStream.ComputeMessageSize(15, Field15);
        }
        if (hasField78) {
          size += pb::CodedOutputStream.ComputeBoolSize(78, Field78);
        }
        if (hasField67) {
          size += pb::CodedOutputStream.ComputeInt32Size(67, Field67);
        }
        if (hasField68) {
          size += pb::CodedOutputStream.ComputeInt32Size(68, Field68);
        }
        if (hasField128) {
          size += pb::CodedOutputStream.ComputeInt32Size(128, Field128);
        }
        if (hasField129) {
          size += pb::CodedOutputStream.ComputeStringSize(129, Field129);
        }
        if (hasField131) {
          size += pb::CodedOutputStream.ComputeInt32Size(131, Field131);
        }
        size += UnknownFields.SerializedSize;
        memoizedSerializedSize = size;
        return size;
      }
    }
    
    public static SpeedMessage1 ParseFrom(pb::ByteString data) {
      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
    }
    public static SpeedMessage1 ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
    }
    public static SpeedMessage1 ParseFrom(byte[] data) {
      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
    }
    public static SpeedMessage1 ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
    }
    public static SpeedMessage1 ParseFrom(global::System.IO.Stream input) {
      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
    }
    public static SpeedMessage1 ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
    }
    public static SpeedMessage1 ParseDelimitedFrom(global::System.IO.Stream input) {
      return CreateBuilder().MergeDelimitedFrom(input).BuildParsed();
    }
    public static SpeedMessage1 ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
      return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed();
    }
    public static SpeedMessage1 ParseFrom(pb::ICodedInputStream input) {
      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
    }
    public static SpeedMessage1 ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
    }
    private SpeedMessage1 MakeReadOnly() {
      field5_.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(SpeedMessage1 prototype) {
      return new Builder(prototype);
    }
    
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    public sealed partial class Builder : pb::GeneratedBuilder<SpeedMessage1, Builder> {
      protected override Builder ThisBuilder {
        get { return this; }
      }
      public Builder() {
        result = DefaultInstance;
        resultIsReadOnly = true;
      }
      internal Builder(SpeedMessage1 cloneFrom) {
        result = cloneFrom;
        resultIsReadOnly = true;
      }
      
      private bool resultIsReadOnly;
      private SpeedMessage1 result;
      
      private SpeedMessage1 PrepareBuilder() {
        if (resultIsReadOnly) {
          SpeedMessage1 original = result;
          result = new SpeedMessage1();
          resultIsReadOnly = false;
          MergeFrom(original);
        }
        return result;
      }
      
      public override bool IsInitialized {
        get { return result.IsInitialized; }
      }
      
      protected override SpeedMessage1 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.SpeedMessage1.Descriptor; }
      }
      
      public override SpeedMessage1 DefaultInstanceForType {
        get { return global::Google.ProtocolBuffers.TestProtos.SpeedMessage1.DefaultInstance; }
      }
      
      public override SpeedMessage1 BuildPartial() {
        if (resultIsReadOnly) {
          return result;
        }
        resultIsReadOnly = true;
        return result.MakeReadOnly();
      }
      
      public override Builder MergeFrom(pb::IMessage other) {
        if (other is SpeedMessage1) {
          return MergeFrom((SpeedMessage1) other);
        } else {
          base.MergeFrom(other);
          return this;
        }
      }
      
      public override Builder MergeFrom(SpeedMessage1 other) {
        if (other == global::Google.ProtocolBuffers.TestProtos.SpeedMessage1.DefaultInstance) return this;
        PrepareBuilder();
        if (other.HasField1) {
          Field1 = other.Field1;
        }
        if (other.HasField9) {
          Field9 = other.Field9;
        }
        if (other.HasField18) {
          Field18 = other.Field18;
        }
        if (other.HasField80) {
          Field80 = other.Field80;
        }
        if (other.HasField81) {
          Field81 = other.Field81;
        }
        if (other.HasField2) {
          Field2 = other.Field2;
        }
        if (other.HasField3) {
          Field3 = other.Field3;
        }
        if (other.HasField280) {
          Field280 = other.Field280;
        }
        if (other.HasField6) {
          Field6 = other.Field6;
        }
        if (other.HasField22) {
          Field22 = other.Field22;
        }
        if (other.HasField4) {
          Field4 = other.Field4;
        }
        if (other.field5_.Count != 0) {
          result.field5_.Add(other.field5_);
        }
        if (other.HasField59) {
          Field59 = other.Field59;
        }
        if (other.HasField7) {
          Field7 = other.Field7;
        }
        if (other.HasField16) {
          Field16 = other.Field16;
        }
        if (other.HasField130) {
          Field130 = other.Field130;
        }
        if (other.HasField12) {
          Field12 = other.Field12;
        }
        if (other.HasField17) {
          Field17 = other.Field17;
        }
        if (other.HasField13) {
          Field13 = other.Field13;
        }
        if (other.HasField14) {
          Field14 = other.Field14;
        }
        if (other.HasField104) {
          Field104 = other.Field104;
        }
        if (other.HasField100) {
          Field100 = other.Field100;
        }
        if (other.HasField101) {
          Field101 = other.Field101;
        }
        if (other.HasField102) {
          Field102 = other.Field102;
        }
        if (other.HasField103) {
          Field103 = other.Field103;
        }
        if (other.HasField29) {
          Field29 = other.Field29;
        }
        if (other.HasField30) {
          Field30 = other.Field30;
        }
        if (other.HasField60) {
          Field60 = other.Field60;
        }
        if (other.HasField271) {
          Field271 = other.Field271;
        }
        if (other.HasField272) {
          Field272 = other.Field272;
        }
        if (other.HasField150) {
          Field150 = other.Field150;
        }
        if (other.HasField23) {
          Field23 = other.Field23;
        }
        if (other.HasField24) {
          Field24 = other.Field24;
        }
        if (other.HasField25) {
          Field25 = other.Field25;
        }
        if (other.HasField15) {
          MergeField15(other.Field15);
        }
        if (other.HasField78) {
          Field78 = other.Field78;
        }
        if (other.HasField67) {
          Field67 = other.Field67;
        }
        if (other.HasField68) {
          Field68 = other.Field68;
        }
        if (other.HasField128) {
          Field128 = other.Field128;
        }
        if (other.HasField129) {
          Field129 = other.Field129;
        }
        if (other.HasField131) {
          Field131 = other.Field131;
        }
        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(_speedMessage1FieldNames, field_name, global::System.StringComparer.Ordinal);
            if(field_ordinal >= 0)
              tag = _speedMessage1FieldTags[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.hasField1 = input.ReadString(ref result.field1_);
              break;
            }
            case 16: {
              result.hasField2 = input.ReadInt32(ref result.field2_);
              break;
            }
            case 24: {
              result.hasField3 = input.ReadInt32(ref result.field3_);
              break;
            }
            case 34: {
              result.hasField4 = input.ReadString(ref result.field4_);
              break;
            }
            case 42:
            case 41: {
              input.ReadFixed64Array(tag, field_name, result.field5_);
              break;
            }
            case 48: {
              result.hasField6 = input.ReadInt32(ref result.field6_);
              break;
            }
            case 58: {
              result.hasField7 = input.ReadString(ref result.field7_);
              break;
            }
            case 74: {
              result.hasField9 = input.ReadString(ref result.field9_);
              break;
            }
            case 96: {
              result.hasField12 = input.ReadBool(ref result.field12_);
              break;
            }
            case 104: {
              result.hasField13 = input.ReadBool(ref result.field13_);
              break;
            }
            case 112: {
              result.hasField14 = input.ReadBool(ref result.field14_);
              break;
            }
            case 122: {
              global::Google.ProtocolBuffers.TestProtos.SpeedMessage1SubMessage.Builder subBuilder = global::Google.ProtocolBuffers.TestProtos.SpeedMessage1SubMessage.CreateBuilder();
              if (result.hasField15) {
                subBuilder.MergeFrom(Field15);
              }
              input.ReadMessage(subBuilder, extensionRegistry);
              Field15 = subBuilder.BuildPartial();
              break;
            }
            case 128: {
              result.hasField16 = input.ReadInt32(ref result.field16_);
              break;
            }
            case 136: {
              result.hasField17 = input.ReadBool(ref result.field17_);
              break;
            }
            case 146: {
              result.hasField18 = input.ReadString(ref result.field18_);
              break;
            }
            case 176: {
              result.hasField22 = input.ReadInt64(ref result.field22_);
              break;
            }
            case 184: {
              result.hasField23 = input.ReadInt32(ref result.field23_);
              break;
            }
            case 192: {
              result.hasField24 = input.ReadBool(ref result.field24_);
              break;
            }
            case 200: {
              result.hasField25 = input.ReadInt32(ref result.field25_);
              break;
            }
            case 232: {
              result.hasField29 = input.ReadInt32(ref result.field29_);
              break;
            }
            case 240: {
              result.hasField30 = input.ReadBool(ref result.field30_);
              break;
            }
            case 472: {
              result.hasField59 = input.ReadBool(ref result.field59_);
              break;
            }
            case 480: {
              result.hasField60 = input.ReadInt32(ref result.field60_);
              break;
            }
            case 536: {
              result.hasField67 = input.ReadInt32(ref result.field67_);
              break;
            }
            case 544: {
              result.hasField68 = input.ReadInt32(ref result.field68_);
              break;
            }
            case 624: {
              result.hasField78 = input.ReadBool(ref result.field78_);
              break;
            }
            case 640: {
              result.hasField80 = input.ReadBool(ref result.field80_);
              break;
            }
            case 648: {
              result.hasField81 = input.ReadBool(ref result.field81_);
              break;
            }
            case 800: {
              result.hasField100 = input.ReadInt32(ref result.field100_);
              break;
            }
            case 808: {
              result.hasField101 = input.ReadInt32(ref result.field101_);
              break;
            }
            case 818: {
              result.hasField102 = input.ReadString(ref result.field102_);
              break;
            }
            case 826: {
              result.hasField103 = input.ReadString(ref result.field103_);
              break;
            }
            case 832: {
              result.hasField104 = input.ReadInt32(ref result.field104_);
              break;
            }
            case 1024: {
              result.hasField128 = input.ReadInt32(ref result.field128_);
              break;
            }
            case 1034: {
              result.hasField129 = input.ReadString(ref result.field129_);
              break;
            }
            case 1040: {
              result.hasField130 = input.ReadInt32(ref result.field130_);
              break;
            }
            case 1048: {
              result.hasField131 = input.ReadInt32(ref result.field131_);
              break;
            }
            case 1200: {
              result.hasField150 = input.ReadInt32(ref result.field150_);
              break;
            }
            case 2168: {
              result.hasField271 = input.ReadInt32(ref result.field271_);
              break;
            }
            case 2176: {
              result.hasField272 = input.ReadInt32(ref result.field272_);
              break;
            }
            case 2240: {
              result.hasField280 = input.ReadInt32(ref result.field280_);
              break;
            }
          }
        }
        
        if (unknownFields != null) {
          this.UnknownFields = unknownFields.Build();
        }
        return this;
      }
      
      
      public bool HasField1 {
        get { return result.hasField1; }
      }
      public string Field1 {
        get { return result.Field1; }
        set { SetField1(value); }
      }
      public Builder SetField1(string value) {
        pb::ThrowHelper.ThrowIfNull(value, "value");
        PrepareBuilder();
        result.hasField1 = true;
        result.field1_ = value;
        return this;
      }
      public Builder ClearField1() {
        PrepareBuilder();
        result.hasField1 = false;
        result.field1_ = "";
        return this;
      }
      
      public bool HasField9 {
        get { return result.hasField9; }
      }
      public string Field9 {
        get { return result.Field9; }
        set { SetField9(value); }
      }
      public Builder SetField9(string value) {
        pb::ThrowHelper.ThrowIfNull(value, "value");
        PrepareBuilder();
        result.hasField9 = true;
        result.field9_ = value;
        return this;
      }
      public Builder ClearField9() {
        PrepareBuilder();
        result.hasField9 = false;
        result.field9_ = "";
        return this;
      }
      
      public bool HasField18 {
        get { return result.hasField18; }
      }
      public string Field18 {
        get { return result.Field18; }
        set { SetField18(value); }
      }
      public Builder SetField18(string value) {
        pb::ThrowHelper.ThrowIfNull(value, "value");
        PrepareBuilder();
        result.hasField18 = true;
        result.field18_ = value;
        return this;
      }
      public Builder ClearField18() {
        PrepareBuilder();
        result.hasField18 = false;
        result.field18_ = "";
        return this;
      }
      
      public bool HasField80 {
        get { return result.hasField80; }
      }
      public bool Field80 {
        get { return result.Field80; }
        set { SetField80(value); }
      }
      public Builder SetField80(bool value) {
        PrepareBuilder();
        result.hasField80 = true;
        result.field80_ = value;
        return this;
      }
      public Builder ClearField80() {
        PrepareBuilder();
        result.hasField80 = false;
        result.field80_ = false;
        return this;
      }
      
      public bool HasField81 {
        get { return result.hasField81; }
      }
      public bool Field81 {
        get { return result.Field81; }
        set { SetField81(value); }
      }
      public Builder SetField81(bool value) {
        PrepareBuilder();
        result.hasField81 = true;
        result.field81_ = value;
        return this;
      }
      public Builder ClearField81() {
        PrepareBuilder();
        result.hasField81 = false;
        result.field81_ = true;
        return this;
      }
      
      public bool HasField2 {
        get { return result.hasField2; }
      }
      public int Field2 {
        get { return result.Field2; }
        set { SetField2(value); }
      }
      public Builder SetField2(int value) {
        PrepareBuilder();
        result.hasField2 = true;
        result.field2_ = value;
        return this;
      }
      public Builder ClearField2() {
        PrepareBuilder();
        result.hasField2 = false;
        result.field2_ = 0;
        return this;
      }
      
      public bool HasField3 {
        get { return result.hasField3; }
      }
      public int Field3 {
        get { return result.Field3; }
        set { SetField3(value); }
      }
      public Builder SetField3(int value) {
        PrepareBuilder();
        result.hasField3 = true;
        result.field3_ = value;
        return this;
      }
      public Builder ClearField3() {
        PrepareBuilder();
        result.hasField3 = false;
        result.field3_ = 0;
        return this;
      }
      
      public bool HasField280 {
        get { return result.hasField280; }
      }
      public int Field280 {
        get { return result.Field280; }
        set { SetField280(value); }
      }
      public Builder SetField280(int value) {
        PrepareBuilder();
        result.hasField280 = true;
        result.field280_ = value;
        return this;
      }
      public Builder ClearField280() {
        PrepareBuilder();
        result.hasField280 = false;
        result.field280_ = 0;
        return this;
      }
      
      public bool HasField6 {
        get { return result.hasField6; }
      }
      public int Field6 {
        get { return result.Field6; }
        set { SetField6(value); }
      }
      public Builder SetField6(int value) {
        PrepareBuilder();
        result.hasField6 = true;
        result.field6_ = value;
        return this;
      }
      public Builder ClearField6() {
        PrepareBuilder();
        result.hasField6 = false;
        result.field6_ = 0;
        return this;
      }
      
      public bool HasField22 {
        get { return result.hasField22; }
      }
      public long Field22 {
        get { return result.Field22; }
        set { SetField22(value); }
      }
      public Builder SetField22(long value) {
        PrepareBuilder();
        result.hasField22 = true;
        result.field22_ = value;
        return this;
      }
      public Builder ClearField22() {
        PrepareBuilder();
        result.hasField22 = false;
        result.field22_ = 0L;
        return this;
      }
      
      public bool HasField4 {
        get { return result.hasField4; }
      }
      public string Field4 {
        get { return result.Field4; }
        set { SetField4(value); }
      }
      public Builder SetField4(string value) {
        pb::ThrowHelper.ThrowIfNull(value, "value");
        PrepareBuilder();
        result.hasField4 = true;
        result.field4_ = value;
        return this;
      }
      public Builder ClearField4() {
        PrepareBuilder();
        result.hasField4 = false;
        result.field4_ = "";
        return this;
      }
      
      [global::System.CLSCompliant(false)]
      public pbc::IPopsicleList<ulong> Field5List {
        get { return PrepareBuilder().field5_; }
      }
      public int Field5Count {
        get { return result.Field5Count; }
      }
      [global::System.CLSCompliant(false)]
      public ulong GetField5(int index) {
        return result.GetField5(index);
      }
      [global::System.CLSCompliant(false)]
      public Builder SetField5(int index, ulong value) {
        PrepareBuilder();
        result.field5_[index] = value;
        return this;
      }
      [global::System.CLSCompliant(false)]
      public Builder AddField5(ulong value) {
        PrepareBuilder();
        result.field5_.Add(value);
        return this;
      }
      [global::System.CLSCompliant(false)]
      public Builder AddRangeField5(scg::IEnumerable<ulong> values) {
        PrepareBuilder();
        result.field5_.Add(values);
        return this;
      }
      public Builder ClearField5() {
        PrepareBuilder();
        result.field5_.Clear();
        return this;
      }
      
      public bool HasField59 {
        get { return result.hasField59; }
      }
      public bool Field59 {
        get { return result.Field59; }
        set { SetField59(value); }
      }
      public Builder SetField59(bool value) {
        PrepareBuilder();
        result.hasField59 = true;
        result.field59_ = value;
        return this;
      }
      public Builder ClearField59() {
        PrepareBuilder();
        result.hasField59 = false;
        result.field59_ = false;
        return this;
      }
      
      public bool HasField7 {
        get { return result.hasField7; }
      }
      public string Field7 {
        get { return result.Field7; }
        set { SetField7(value); }
      }
      public Builder SetField7(string value) {
        pb::ThrowHelper.ThrowIfNull(value, "value");
        PrepareBuilder();
        result.hasField7 = true;
        result.field7_ = value;
        return this;
      }
      public Builder ClearField7() {
        PrepareBuilder();
        result.hasField7 = false;
        result.field7_ = "";
        return this;
      }
      
      public bool HasField16 {
        get { return result.hasField16; }
      }
      public int Field16 {
        get { return result.Field16; }
        set { SetField16(value); }
      }
      public Builder SetField16(int value) {
        PrepareBuilder();
        result.hasField16 = true;
        result.field16_ = value;
        return this;
      }
      public Builder ClearField16() {
        PrepareBuilder();
        result.hasField16 = false;
        result.field16_ = 0;
        return this;
      }
      
      public bool HasField130 {
        get { return result.hasField130; }
      }
      public int Field130 {
        get { return result.Field130; }
        set { SetField130(value); }
      }
      public Builder SetField130(int value) {
        PrepareBuilder();
        result.hasField130 = true;
        result.field130_ = value;
        return this;
      }
      public Builder ClearField130() {
        PrepareBuilder();
        result.hasField130 = false;
        result.field130_ = 0;
        return this;
      }
      
      public bool HasField12 {
        get { return result.hasField12; }
      }
      public bool Field12 {
        get { return result.Field12; }
        set { SetField12(value); }
      }
      public Builder SetField12(bool value) {
        PrepareBuilder();
        result.hasField12 = true;
        result.field12_ = value;
        return this;
      }
      public Builder ClearField12() {
        PrepareBuilder();
        result.hasField12 = false;
        result.field12_ = true;
        return this;
      }
      
      public bool HasField17 {
        get { return result.hasField17; }
      }
      public bool Field17 {
        get { return result.Field17; }
        set { SetField17(value); }
      }
      public Builder SetField17(bool value) {
        PrepareBuilder();
        result.hasField17 = true;
        result.field17_ = value;
        return this;
      }
      public Builder ClearField17() {
        PrepareBuilder();
        result.hasField17 = false;
        result.field17_ = true;
        return this;
      }
      
      public bool HasField13 {
        get { return result.hasField13; }
      }
      public bool Field13 {
        get { return result.Field13; }
        set { SetField13(value); }
      }
      public Builder SetField13(bool value) {
        PrepareBuilder();
        result.hasField13 = true;
        result.field13_ = value;
        return this;
      }
      public Builder ClearField13() {
        PrepareBuilder();
        result.hasField13 = false;
        result.field13_ = true;
        return this;
      }
      
      public bool HasField14 {
        get { return result.hasField14; }
      }
      public bool Field14 {
        get { return result.Field14; }
        set { SetField14(value); }
      }
      public Builder SetField14(bool value) {
        PrepareBuilder();
        result.hasField14 = true;
        result.field14_ = value;
        return this;
      }
      public Builder ClearField14() {
        PrepareBuilder();
        result.hasField14 = false;
        result.field14_ = true;
        return this;
      }
      
      public bool HasField104 {
        get { return result.hasField104; }
      }
      public int Field104 {
        get { return result.Field104; }
        set { SetField104(value); }
      }
      public Builder SetField104(int value) {
        PrepareBuilder();
        result.hasField104 = true;
        result.field104_ = value;
        return this;
      }
      public Builder ClearField104() {
        PrepareBuilder();
        result.hasField104 = false;
        result.field104_ = 0;
        return this;
      }
      
      public bool HasField100 {
        get { return result.hasField100; }
      }
      public int Field100 {
        get { return result.Field100; }
        set { SetField100(value); }
      }
      public Builder SetField100(int value) {
        PrepareBuilder();
        result.hasField100 = true;
        result.field100_ = value;
        return this;
      }
      public Builder ClearField100() {
        PrepareBuilder();
        result.hasField100 = false;
        result.field100_ = 0;
        return this;
      }
      
      public bool HasField101 {
        get { return result.hasField101; }
      }
      public int Field101 {
        get { return result.Field101; }
        set { SetField101(value); }
      }
      public Builder SetField101(int value) {
        PrepareBuilder();
        result.hasField101 = true;
        result.field101_ = value;
        return this;
      }
      public Builder ClearField101() {
        PrepareBuilder();
        result.hasField101 = false;
        result.field101_ = 0;
        return this;
      }
      
      public bool HasField102 {
        get { return result.hasField102; }
      }
      public string Field102 {
        get { return result.Field102; }
        set { SetField102(value); }
      }
      public Builder SetField102(string value) {
        pb::ThrowHelper.ThrowIfNull(value, "value");
        PrepareBuilder();
        result.hasField102 = true;
        result.field102_ = value;
        return this;
      }
      public Builder ClearField102() {
        PrepareBuilder();
        result.hasField102 = false;
        result.field102_ = "";
        return this;
      }
      
      public bool HasField103 {
        get { return result.hasField103; }
      }
      public string Field103 {
        get { return result.Field103; }
        set { SetField103(value); }
      }
      public Builder SetField103(string value) {
        pb::ThrowHelper.ThrowIfNull(value, "value");
        PrepareBuilder();
        result.hasField103 = true;
        result.field103_ = value;
        return this;
      }
      public Builder ClearField103() {
        PrepareBuilder();
        result.hasField103 = false;
        result.field103_ = "";
        return this;
      }
      
      public bool HasField29 {
        get { return result.hasField29; }
      }
      public int Field29 {
        get { return result.Field29; }
        set { SetField29(value); }
      }
      public Builder SetField29(int value) {
        PrepareBuilder();
        result.hasField29 = true;
        result.field29_ = value;
        return this;
      }
      public Builder ClearField29() {
        PrepareBuilder();
        result.hasField29 = false;
        result.field29_ = 0;
        return this;
      }
      
      public bool HasField30 {
        get { return result.hasField30; }
      }
      public bool Field30 {
        get { return result.Field30; }
        set { SetField30(value); }
      }
      public Builder SetField30(bool value) {
        PrepareBuilder();
        result.hasField30 = true;
        result.field30_ = value;
        return this;
      }
      public Builder ClearField30() {
        PrepareBuilder();
        result.hasField30 = false;
        result.field30_ = false;
        return this;
      }
      
      public bool HasField60 {
        get { return result.hasField60; }
      }
      public int Field60 {
        get { return result.Field60; }
        set { SetField60(value); }
      }
      public Builder SetField60(int value) {
        PrepareBuilder();
        result.hasField60 = true;
        result.field60_ = value;
        return this;
      }
      public Builder ClearField60() {
        PrepareBuilder();
        result.hasField60 = false;
        result.field60_ = -1;
        return this;
      }
      
      public bool HasField271 {
        get { return result.hasField271; }
      }
      public int Field271 {
        get { return result.Field271; }
        set { SetField271(value); }
      }
      public Builder SetField271(int value) {
        PrepareBuilder();
        result.hasField271 = true;
        result.field271_ = value;
        return this;
      }
      public Builder ClearField271() {
        PrepareBuilder();
        result.hasField271 = false;
        result.field271_ = -1;
        return this;
      }
      
      public bool HasField272 {
        get { return result.hasField272; }
      }
      public int Field272 {
        get { return result.Field272; }
        set { SetField272(value); }
      }
      public Builder SetField272(int value) {
        PrepareBuilder();
        result.hasField272 = true;
        result.field272_ = value;
        return this;
      }
      public Builder ClearField272() {
        PrepareBuilder();
        result.hasField272 = false;
        result.field272_ = -1;
        return this;
      }
      
      public bool HasField150 {
        get { return result.hasField150; }
      }
      public int Field150 {
        get { return result.Field150; }
        set { SetField150(value); }
      }
      public Builder SetField150(int value) {
        PrepareBuilder();
        result.hasField150 = true;
        result.field150_ = value;
        return this;
      }
      public Builder ClearField150() {
        PrepareBuilder();
        result.hasField150 = false;
        result.field150_ = 0;
        return this;
      }
      
      public bool HasField23 {
        get { return result.hasField23; }
      }
      public int Field23 {
        get { return result.Field23; }
        set { SetField23(value); }
      }
      public Builder SetField23(int value) {
        PrepareBuilder();
        result.hasField23 = true;
        result.field23_ = value;
        return this;
      }
      public Builder ClearField23() {
        PrepareBuilder();
        result.hasField23 = false;
        result.field23_ = 0;
        return this;
      }
      
      public bool HasField24 {
        get { return result.hasField24; }
      }
      public bool Field24 {
        get { return result.Field24; }
        set { SetField24(value); }
      }
      public Builder SetField24(bool value) {
        PrepareBuilder();
        result.hasField24 = true;
        result.field24_ = value;
        return this;
      }
      public Builder ClearField24() {
        PrepareBuilder();
        result.hasField24 = false;
        result.field24_ = false;
        return this;
      }
      
      public bool HasField25 {
        get { return result.hasField25; }
      }
      public int Field25 {
        get { return result.Field25; }
        set { SetField25(value); }
      }
      public Builder SetField25(int value) {
        PrepareBuilder();
        result.hasField25 = true;
        result.field25_ = value;
        return this;
      }
      public Builder ClearField25() {
        PrepareBuilder();
        result.hasField25 = false;
        result.field25_ = 0;
        return this;
      }
      
      public bool HasField15 {
       get { return result.hasField15; }
      }
      public global::Google.ProtocolBuffers.TestProtos.SpeedMessage1SubMessage Field15 {
        get { return result.Field15; }
        set { SetField15(value); }
      }
      public Builder SetField15(global::Google.ProtocolBuffers.TestProtos.SpeedMessage1SubMessage value) {
        pb::ThrowHelper.ThrowIfNull(value, "value");
        PrepareBuilder();
        result.hasField15 = true;
        result.field15_ = value;
        return this;
      }
      public Builder SetField15(global::Google.ProtocolBuffers.TestProtos.SpeedMessage1SubMessage.Builder builderForValue) {
        pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue");
        PrepareBuilder();
        result.hasField15 = true;
        result.field15_ = builderForValue.Build();
        return this;
      }
      public Builder MergeField15(global::Google.ProtocolBuffers.TestProtos.SpeedMessage1SubMessage value) {
        pb::ThrowHelper.ThrowIfNull(value, "value");
        PrepareBuilder();
        if (result.hasField15 &&
            result.field15_ != global::Google.ProtocolBuffers.TestProtos.SpeedMessage1SubMessage.DefaultInstance) {
            result.field15_ = global::Google.ProtocolBuffers.TestProtos.SpeedMessage1SubMessage.CreateBuilder(result.field15_).MergeFrom(value).BuildPartial();
        } else {
          result.field15_ = value;
        }
        result.hasField15 = true;
        return this;
      }
      public Builder ClearField15() {
        PrepareBuilder();
        result.hasField15 = false;
        result.field15_ = null;
        return this;
      }
      
      public bool HasField78 {
        get { return result.hasField78; }
      }
      public bool Field78 {
        get { return result.Field78; }
        set { SetField78(value); }
      }
      public Builder SetField78(bool value) {
        PrepareBuilder();
        result.hasField78 = true;
        result.field78_ = value;
        return this;
      }
      public Builder ClearField78() {
        PrepareBuilder();
        result.hasField78 = false;
        result.field78_ = false;
        return this;
      }
      
      public bool HasField67 {
        get { return result.hasField67; }
      }
      public int Field67 {
        get { return result.Field67; }
        set { SetField67(value); }
      }
      public Builder SetField67(int value) {
        PrepareBuilder();
        result.hasField67 = true;
        result.field67_ = value;
        return this;
      }
      public Builder ClearField67() {
        PrepareBuilder();
        result.hasField67 = false;
        result.field67_ = 0;
        return this;
      }
      
      public bool HasField68 {
        get { return result.hasField68; }
      }
      public int Field68 {
        get { return result.Field68; }
        set { SetField68(value); }
      }
      public Builder SetField68(int value) {
        PrepareBuilder();
        result.hasField68 = true;
        result.field68_ = value;
        return this;
      }
      public Builder ClearField68() {
        PrepareBuilder();
        result.hasField68 = false;
        result.field68_ = 0;
        return this;
      }
      
      public bool HasField128 {
        get { return result.hasField128; }
      }
      public int Field128 {
        get { return result.Field128; }
        set { SetField128(value); }
      }
      public Builder SetField128(int value) {
        PrepareBuilder();
        result.hasField128 = true;
        result.field128_ = value;
        return this;
      }
      public Builder ClearField128() {
        PrepareBuilder();
        result.hasField128 = false;
        result.field128_ = 0;
        return this;
      }
      
      public bool HasField129 {
        get { return result.hasField129; }
      }
      public string Field129 {
        get { return result.Field129; }
        set { SetField129(value); }
      }
      public Builder SetField129(string value) {
        pb::ThrowHelper.ThrowIfNull(value, "value");
        PrepareBuilder();
        result.hasField129 = true;
        result.field129_ = value;
        return this;
      }
      public Builder ClearField129() {
        PrepareBuilder();
        result.hasField129 = false;
        result.field129_ = "xxxxxxxxxxxxxxxxxxxxx";
        return this;
      }
      
      public bool HasField131 {
        get { return result.hasField131; }
      }
      public int Field131 {
        get { return result.Field131; }
        set { SetField131(value); }
      }
      public Builder SetField131(int value) {
        PrepareBuilder();
        result.hasField131 = true;
        result.field131_ = value;
        return this;
      }
      public Builder ClearField131() {
        PrepareBuilder();
        result.hasField131 = false;
        result.field131_ = 0;
        return this;
      }
    }
    static SpeedMessage1() {
      object.ReferenceEquals(global::Google.ProtocolBuffers.TestProtos.UnitTestGoogleSpeedProtoFile.Descriptor, null);
    }
  }
  
  [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
  public sealed partial class SpeedMessage1SubMessage : pb::GeneratedMessage<SpeedMessage1SubMessage, SpeedMessage1SubMessage.Builder> {
    private SpeedMessage1SubMessage() { }
    private static readonly SpeedMessage1SubMessage defaultInstance = new SpeedMessage1SubMessage().MakeReadOnly();
    private static readonly string[] _speedMessage1SubMessageFieldNames = new string[] { "field1", "field12", "field13", "field14", "field15", "field16", "field19", "field2", "field20", "field203", "field204", "field205", "field206", "field207", "field21", "field22", "field23", "field28", "field3", "field300" };
    private static readonly uint[] _speedMessage1SubMessageFieldTags = new uint[] { 8, 96, 104, 112, 122, 128, 152, 16, 160, 1629, 1632, 1642, 1648, 1656, 169, 176, 184, 224, 24, 2400 };
    public static SpeedMessage1SubMessage DefaultInstance {
      get { return defaultInstance; }
    }
    
    public override SpeedMessage1SubMessage DefaultInstanceForType {
      get { return DefaultInstance; }
    }
    
    protected override SpeedMessage1SubMessage ThisMessage {
      get { return this; }
    }
    
    public static pbd::MessageDescriptor Descriptor {
      get { return global::Google.ProtocolBuffers.TestProtos.UnitTestGoogleSpeedProtoFile.internal__static_unittest_google_speed_SpeedMessage1SubMessage__Descriptor; }
    }
    
    protected override pb::FieldAccess.FieldAccessorTable<SpeedMessage1SubMessage, SpeedMessage1SubMessage.Builder> InternalFieldAccessors {
      get { return global::Google.ProtocolBuffers.TestProtos.UnitTestGoogleSpeedProtoFile.internal__static_unittest_google_speed_SpeedMessage1SubMessage__FieldAccessorTable; }
    }
    
    public const int Field1FieldNumber = 1;
    private bool hasField1;
    private int field1_;
    public bool HasField1 {
      get { return hasField1; }
    }
    public int Field1 {
      get { return field1_; }
    }
    
    public const int Field2FieldNumber = 2;
    private bool hasField2;
    private int field2_;
    public bool HasField2 {
      get { return hasField2; }
    }
    public int Field2 {
      get { return field2_; }
    }
    
    public const int Field3FieldNumber = 3;
    private bool hasField3;
    private int field3_;
    public bool HasField3 {
      get { return hasField3; }
    }
    public int Field3 {
      get { return field3_; }
    }
    
    public const int Field15FieldNumber = 15;
    private bool hasField15;
    private string field15_ = "";
    public bool HasField15 {
      get { return hasField15; }
    }
    public string Field15 {
      get { return field15_; }
    }
    
    public const int Field12FieldNumber = 12;
    private bool hasField12;
    private bool field12_ = true;
    public bool HasField12 {
      get { return hasField12; }
    }
    public bool Field12 {
      get { return field12_; }
    }
    
    public const int Field13FieldNumber = 13;
    private bool hasField13;
    private long field13_;
    public bool HasField13 {
      get { return hasField13; }
    }
    public long Field13 {
      get { return field13_; }
    }
    
    public const int Field14FieldNumber = 14;
    private bool hasField14;
    private long field14_;
    public bool HasField14 {
      get { return hasField14; }
    }
    public long Field14 {
      get { return field14_; }
    }
    
    public const int Field16FieldNumber = 16;
    private bool hasField16;
    private int field16_;
    public bool HasField16 {
      get { return hasField16; }
    }
    public int Field16 {
      get { return field16_; }
    }
    
    public const int Field19FieldNumber = 19;
    private bool hasField19;
    private int field19_ = 2;
    public bool HasField19 {
      get { return hasField19; }
    }
    public int Field19 {
      get { return field19_; }
    }
    
    public const int Field20FieldNumber = 20;
    private bool hasField20;
    private bool field20_ = true;
    public bool HasField20 {
      get { return hasField20; }
    }
    public bool Field20 {
      get { return field20_; }
    }
    
    public const int Field28FieldNumber = 28;
    private bool hasField28;
    private bool field28_ = true;
    public bool HasField28 {
      get { return hasField28; }
    }
    public bool Field28 {
      get { return field28_; }
    }
    
    public const int Field21FieldNumber = 21;
    private bool hasField21;
    private ulong field21_;
    public bool HasField21 {
      get { return hasField21; }
    }
    [global::System.CLSCompliant(false)]
    public ulong Field21 {
      get { return field21_; }
    }
    
    public const int Field22FieldNumber = 22;
    private bool hasField22;
    private int field22_;
    public bool HasField22 {
      get { return hasField22; }
    }
    public int Field22 {
      get { return field22_; }
    }
    
    public const int Field23FieldNumber = 23;
    private bool hasField23;
    private bool field23_;
    public bool HasField23 {
      get { return hasField23; }
    }
    public bool Field23 {
      get { return field23_; }
    }
    
    public const int Field206FieldNumber = 206;
    private bool hasField206;
    private bool field206_;
    public bool HasField206 {
      get { return hasField206; }
    }
    public bool Field206 {
      get { return field206_; }
    }
    
    public const int Field203FieldNumber = 203;
    private bool hasField203;
    private uint field203_;
    public bool HasField203 {
      get { return hasField203; }
    }
    [global::System.CLSCompliant(false)]
    public uint Field203 {
      get { return field203_; }
    }
    
    public const int Field204FieldNumber = 204;
    private bool hasField204;
    private int field204_;
    public bool HasField204 {
      get { return hasField204; }
    }
    public int Field204 {
      get { return field204_; }
    }
    
    public const int Field205FieldNumber = 205;
    private bool hasField205;
    private string field205_ = "";
    public bool HasField205 {
      get { return hasField205; }
    }
    public string Field205 {
      get { return field205_; }
    }
    
    public const int Field207FieldNumber = 207;
    private bool hasField207;
    private ulong field207_;
    public bool HasField207 {
      get { return hasField207; }
    }
    [global::System.CLSCompliant(false)]
    public ulong Field207 {
      get { return field207_; }
    }
    
    public const int Field300FieldNumber = 300;
    private bool hasField300;
    private ulong field300_;
    public bool HasField300 {
      get { return hasField300; }
    }
    [global::System.CLSCompliant(false)]
    public ulong Field300 {
      get { return field300_; }
    }
    
    public override bool IsInitialized {
      get {
        return true;
      }
    }
    
    public override void WriteTo(pb::ICodedOutputStream output) {
      int size = SerializedSize;
      string[] field_names = _speedMessage1SubMessageFieldNames;
      if (hasField1) {
        output.WriteInt32(1, field_names[0], Field1);
      }
      if (hasField2) {
        output.WriteInt32(2, field_names[7], Field2);
      }
      if (hasField3) {
        output.WriteInt32(3, field_names[18], Field3);
      }
      if (hasField12) {
        output.WriteBool(12, field_names[1], Field12);
      }
      if (hasField13) {
        output.WriteInt64(13, field_names[2], Field13);
      }
      if (hasField14) {
        output.WriteInt64(14, field_names[3], Field14);
      }
      if (hasField15) {
        output.WriteString(15, field_names[4], Field15);
      }
      if (hasField16) {
        output.WriteInt32(16, field_names[5], Field16);
      }
      if (hasField19) {
        output.WriteInt32(19, field_names[6], Field19);
      }
      if (hasField20) {
        output.WriteBool(20, field_names[8], Field20);
      }
      if (hasField21) {
        output.WriteFixed64(21, field_names[14], Field21);
      }
      if (hasField22) {
        output.WriteInt32(22, field_names[15], Field22);
      }
      if (hasField23) {
        output.WriteBool(23, field_names[16], Field23);
      }
      if (hasField28) {
        output.WriteBool(28, field_names[17], Field28);
      }
      if (hasField203) {
        output.WriteFixed32(203, field_names[9], Field203);
      }
      if (hasField204) {
        output.WriteInt32(204, field_names[10], Field204);
      }
      if (hasField205) {
        output.WriteString(205, field_names[11], Field205);
      }
      if (hasField206) {
        output.WriteBool(206, field_names[12], Field206);
      }
      if (hasField207) {
        output.WriteUInt64(207, field_names[13], Field207);
      }
      if (hasField300) {
        output.WriteUInt64(300, field_names[19], Field300);
      }
      UnknownFields.WriteTo(output);
    }
    
    private int memoizedSerializedSize = -1;
    public override int SerializedSize {
      get {
        int size = memoizedSerializedSize;
        if (size != -1) return size;
        
        size = 0;
        if (hasField1) {
          size += pb::CodedOutputStream.ComputeInt32Size(1, Field1);
        }
        if (hasField2) {
          size += pb::CodedOutputStream.ComputeInt32Size(2, Field2);
        }
        if (hasField3) {
          size += pb::CodedOutputStream.ComputeInt32Size(3, Field3);
        }
        if (hasField15) {
          size += pb::CodedOutputStream.ComputeStringSize(15, Field15);
        }
        if (hasField12) {
          size += pb::CodedOutputStream.ComputeBoolSize(12, Field12);
        }
        if (hasField13) {
          size += pb::CodedOutputStream.ComputeInt64Size(13, Field13);
        }
        if (hasField14) {
          size += pb::CodedOutputStream.ComputeInt64Size(14, Field14);
        }
        if (hasField16) {
          size += pb::CodedOutputStream.ComputeInt32Size(16, Field16);
        }
        if (hasField19) {
          size += pb::CodedOutputStream.ComputeInt32Size(19, Field19);
        }
        if (hasField20) {
          size += pb::CodedOutputStream.ComputeBoolSize(20, Field20);
        }
        if (hasField28) {
          size += pb::CodedOutputStream.ComputeBoolSize(28, Field28);
        }
        if (hasField21) {
          size += pb::CodedOutputStream.ComputeFixed64Size(21, Field21);
        }
        if (hasField22) {
          size += pb::CodedOutputStream.ComputeInt32Size(22, Field22);
        }
        if (hasField23) {
          size += pb::CodedOutputStream.ComputeBoolSize(23, Field23);
        }
        if (hasField206) {
          size += pb::CodedOutputStream.ComputeBoolSize(206, Field206);
        }
        if (hasField203) {
          size += pb::CodedOutputStream.ComputeFixed32Size(203, Field203);
        }
        if (hasField204) {
          size += pb::CodedOutputStream.ComputeInt32Size(204, Field204);
        }
        if (hasField205) {
          size += pb::CodedOutputStream.ComputeStringSize(205, Field205);
        }
        if (hasField207) {
          size += pb::CodedOutputStream.ComputeUInt64Size(207, Field207);
        }
        if (hasField300) {
          size += pb::CodedOutputStream.ComputeUInt64Size(300, Field300);
        }
        size += UnknownFields.SerializedSize;
        memoizedSerializedSize = size;
        return size;
      }
    }
    
    public static SpeedMessage1SubMessage ParseFrom(pb::ByteString data) {
      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
    }
    public static SpeedMessage1SubMessage ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
    }
    public static SpeedMessage1SubMessage ParseFrom(byte[] data) {
      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
    }
    public static SpeedMessage1SubMessage ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
    }
    public static SpeedMessage1SubMessage ParseFrom(global::System.IO.Stream input) {
      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
    }
    public static SpeedMessage1SubMessage ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
    }
    public static SpeedMessage1SubMessage ParseDelimitedFrom(global::System.IO.Stream input) {
      return CreateBuilder().MergeDelimitedFrom(input).BuildParsed();
    }
    public static SpeedMessage1SubMessage ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
      return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed();
    }
    public static SpeedMessage1SubMessage ParseFrom(pb::ICodedInputStream input) {
      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
    }
    public static SpeedMessage1SubMessage ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
    }
    private SpeedMessage1SubMessage 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(SpeedMessage1SubMessage prototype) {
      return new Builder(prototype);
    }
    
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    public sealed partial class Builder : pb::GeneratedBuilder<SpeedMessage1SubMessage, Builder> {
      protected override Builder ThisBuilder {
        get { return this; }
      }
      public Builder() {
        result = DefaultInstance;
        resultIsReadOnly = true;
      }
      internal Builder(SpeedMessage1SubMessage cloneFrom) {
        result = cloneFrom;
        resultIsReadOnly = true;
      }
      
      private bool resultIsReadOnly;
      private SpeedMessage1SubMessage result;
      
      private SpeedMessage1SubMessage PrepareBuilder() {
        if (resultIsReadOnly) {
          SpeedMessage1SubMessage original = result;
          result = new SpeedMessage1SubMessage();
          resultIsReadOnly = false;
          MergeFrom(original);
        }
        return result;
      }
      
      public override bool IsInitialized {
        get { return result.IsInitialized; }
      }
      
      protected override SpeedMessage1SubMessage 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.SpeedMessage1SubMessage.Descriptor; }
      }
      
      public override SpeedMessage1SubMessage DefaultInstanceForType {
        get { return global::Google.ProtocolBuffers.TestProtos.SpeedMessage1SubMessage.DefaultInstance; }
      }
      
      public override SpeedMessage1SubMessage BuildPartial() {
        if (resultIsReadOnly) {
          return result;
        }
        resultIsReadOnly = true;
        return result.MakeReadOnly();
      }
      
      public override Builder MergeFrom(pb::IMessage other) {
        if (other is SpeedMessage1SubMessage) {
          return MergeFrom((SpeedMessage1SubMessage) other);
        } else {
          base.MergeFrom(other);
          return this;
        }
      }
      
      public override Builder MergeFrom(SpeedMessage1SubMessage other) {
        if (other == global::Google.ProtocolBuffers.TestProtos.SpeedMessage1SubMessage.DefaultInstance) return this;
        PrepareBuilder();
        if (other.HasField1) {
          Field1 = other.Field1;
        }
        if (other.HasField2) {
          Field2 = other.Field2;
        }
        if (other.HasField3) {
          Field3 = other.Field3;
        }
        if (other.HasField15) {
          Field15 = other.Field15;
        }
        if (other.HasField12) {
          Field12 = other.Field12;
        }
        if (other.HasField13) {
          Field13 = other.Field13;
        }
        if (other.HasField14) {
          Field14 = other.Field14;
        }
        if (other.HasField16) {
          Field16 = other.Field16;
        }
        if (other.HasField19) {
          Field19 = other.Field19;
        }
        if (other.HasField20) {
          Field20 = other.Field20;
        }
        if (other.HasField28) {
          Field28 = other.Field28;
        }
        if (other.HasField21) {
          Field21 = other.Field21;
        }
        if (other.HasField22) {
          Field22 = other.Field22;
        }
        if (other.HasField23) {
          Field23 = other.Field23;
        }
        if (other.HasField206) {
          Field206 = other.Field206;
        }
        if (other.HasField203) {
          Field203 = other.Field203;
        }
        if (other.HasField204) {
          Field204 = other.Field204;
        }
        if (other.HasField205) {
          Field205 = other.Field205;
        }
        if (other.HasField207) {
          Field207 = other.Field207;
        }
        if (other.HasField300) {
          Field300 = other.Field300;
        }
        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(_speedMessage1SubMessageFieldNames, field_name, global::System.StringComparer.Ordinal);
            if(field_ordinal >= 0)
              tag = _speedMessage1SubMessageFieldTags[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.hasField1 = input.ReadInt32(ref result.field1_);
              break;
            }
            case 16: {
              result.hasField2 = input.ReadInt32(ref result.field2_);
              break;
            }
            case 24: {
              result.hasField3 = input.ReadInt32(ref result.field3_);
              break;
            }
            case 96: {
              result.hasField12 = input.ReadBool(ref result.field12_);
              break;
            }
            case 104: {
              result.hasField13 = input.ReadInt64(ref result.field13_);
              break;
            }
            case 112: {
              result.hasField14 = input.ReadInt64(ref result.field14_);
              break;
            }
            case 122: {
              result.hasField15 = input.ReadString(ref result.field15_);
              break;
            }
            case 128: {
              result.hasField16 = input.ReadInt32(ref result.field16_);
              break;
            }
            case 152: {
              result.hasField19 = input.ReadInt32(ref result.field19_);
              break;
            }
            case 160: {
              result.hasField20 = input.ReadBool(ref result.field20_);
              break;
            }
            case 169: {
              result.hasField21 = input.ReadFixed64(ref result.field21_);
              break;
            }
            case 176: {
              result.hasField22 = input.ReadInt32(ref result.field22_);
              break;
            }
            case 184: {
              result.hasField23 = input.ReadBool(ref result.field23_);
              break;
            }
            case 224: {
              result.hasField28 = input.ReadBool(ref result.field28_);
              break;
            }
            case 1629: {
              result.hasField203 = input.ReadFixed32(ref result.field203_);
              break;
            }
            case 1632: {
              result.hasField204 = input.ReadInt32(ref result.field204_);
              break;
            }
            case 1642: {
              result.hasField205 = input.ReadString(ref result.field205_);
              break;
            }
            case 1648: {
              result.hasField206 = input.ReadBool(ref result.field206_);
              break;
            }
            case 1656: {
              result.hasField207 = input.ReadUInt64(ref result.field207_);
              break;
            }
            case 2400: {
              result.hasField300 = input.ReadUInt64(ref result.field300_);
              break;
            }
          }
        }
        
        if (unknownFields != null) {
          this.UnknownFields = unknownFields.Build();
        }
        return this;
      }
      
      
      public bool HasField1 {
        get { return result.hasField1; }
      }
      public int Field1 {
        get { return result.Field1; }
        set { SetField1(value); }
      }
      public Builder SetField1(int value) {
        PrepareBuilder();
        result.hasField1 = true;
        result.field1_ = value;
        return this;
      }
      public Builder ClearField1() {
        PrepareBuilder();
        result.hasField1 = false;
        result.field1_ = 0;
        return this;
      }
      
      public bool HasField2 {
        get { return result.hasField2; }
      }
      public int Field2 {
        get { return result.Field2; }
        set { SetField2(value); }
      }
      public Builder SetField2(int value) {
        PrepareBuilder();
        result.hasField2 = true;
        result.field2_ = value;
        return this;
      }
      public Builder ClearField2() {
        PrepareBuilder();
        result.hasField2 = false;
        result.field2_ = 0;
        return this;
      }
      
      public bool HasField3 {
        get { return result.hasField3; }
      }
      public int Field3 {
        get { return result.Field3; }
        set { SetField3(value); }
      }
      public Builder SetField3(int value) {
        PrepareBuilder();
        result.hasField3 = true;
        result.field3_ = value;
        return this;
      }
      public Builder ClearField3() {
        PrepareBuilder();
        result.hasField3 = false;
        result.field3_ = 0;
        return this;
      }
      
      public bool HasField15 {
        get { return result.hasField15; }
      }
      public string Field15 {
        get { return result.Field15; }
        set { SetField15(value); }
      }
      public Builder SetField15(string value) {
        pb::ThrowHelper.ThrowIfNull(value, "value");
        PrepareBuilder();
        result.hasField15 = true;
        result.field15_ = value;
        return this;
      }
      public Builder ClearField15() {
        PrepareBuilder();
        result.hasField15 = false;
        result.field15_ = "";
        return this;
      }
      
      public bool HasField12 {
        get { return result.hasField12; }
      }
      public bool Field12 {
        get { return result.Field12; }
        set { SetField12(value); }
      }
      public Builder SetField12(bool value) {
        PrepareBuilder();
        result.hasField12 = true;
        result.field12_ = value;
        return this;
      }
      public Builder ClearField12() {
        PrepareBuilder();
        result.hasField12 = false;
        result.field12_ = true;
        return this;
      }
      
      public bool HasField13 {
        get { return result.hasField13; }
      }
      public long Field13 {
        get { return result.Field13; }
        set { SetField13(value); }
      }
      public Builder SetField13(long value) {
        PrepareBuilder();
        result.hasField13 = true;
        result.field13_ = value;
        return this;
      }
      public Builder ClearField13() {
        PrepareBuilder();
        result.hasField13 = false;
        result.field13_ = 0L;
        return this;
      }
      
      public bool HasField14 {
        get { return result.hasField14; }
      }
      public long Field14 {
        get { return result.Field14; }
        set { SetField14(value); }
      }
      public Builder SetField14(long value) {
        PrepareBuilder();
        result.hasField14 = true;
        result.field14_ = value;
        return this;
      }
      public Builder ClearField14() {
        PrepareBuilder();
        result.hasField14 = false;
        result.field14_ = 0L;
        return this;
      }
      
      public bool HasField16 {
        get { return result.hasField16; }
      }
      public int Field16 {
        get { return result.Field16; }
        set { SetField16(value); }
      }
      public Builder SetField16(int value) {
        PrepareBuilder();
        result.hasField16 = true;
        result.field16_ = value;
        return this;
      }
      public Builder ClearField16() {
        PrepareBuilder();
        result.hasField16 = false;
        result.field16_ = 0;
        return this;
      }
      
      public bool HasField19 {
        get { return result.hasField19; }
      }
      public int Field19 {
        get { return result.Field19; }
        set { SetField19(value); }
      }
      public Builder SetField19(int value) {
        PrepareBuilder();
        result.hasField19 = true;
        result.field19_ = value;
        return this;
      }
      public Builder ClearField19() {
        PrepareBuilder();
        result.hasField19 = false;
        result.field19_ = 2;
        return this;
      }
      
      public bool HasField20 {
        get { return result.hasField20; }
      }
      public bool Field20 {
        get { return result.Field20; }
        set { SetField20(value); }
      }
      public Builder SetField20(bool value) {
        PrepareBuilder();
        result.hasField20 = true;
        result.field20_ = value;
        return this;
      }
      public Builder ClearField20() {
        PrepareBuilder();
        result.hasField20 = false;
        result.field20_ = true;
        return this;
      }
      
      public bool HasField28 {
        get { return result.hasField28; }
      }
      public bool Field28 {
        get { return result.Field28; }
        set { SetField28(value); }
      }
      public Builder SetField28(bool value) {
        PrepareBuilder();
        result.hasField28 = true;
        result.field28_ = value;
        return this;
      }
      public Builder ClearField28() {
        PrepareBuilder();
        result.hasField28 = false;
        result.field28_ = true;
        return this;
      }
      
      public bool HasField21 {
        get { return result.hasField21; }
      }
      [global::System.CLSCompliant(false)]
      public ulong Field21 {
        get { return result.Field21; }
        set { SetField21(value); }
      }
      [global::System.CLSCompliant(false)]
      public Builder SetField21(ulong value) {
        PrepareBuilder();
        result.hasField21 = true;
        result.field21_ = value;
        return this;
      }
      public Builder ClearField21() {
        PrepareBuilder();
        result.hasField21 = false;
        result.field21_ = 0;
        return this;
      }
      
      public bool HasField22 {
        get { return result.hasField22; }
      }
      public int Field22 {
        get { return result.Field22; }
        set { SetField22(value); }
      }
      public Builder SetField22(int value) {
        PrepareBuilder();
        result.hasField22 = true;
        result.field22_ = value;
        return this;
      }
      public Builder ClearField22() {
        PrepareBuilder();
        result.hasField22 = false;
        result.field22_ = 0;
        return this;
      }
      
      public bool HasField23 {
        get { return result.hasField23; }
      }
      public bool Field23 {
        get { return result.Field23; }
        set { SetField23(value); }
      }
      public Builder SetField23(bool value) {
        PrepareBuilder();
        result.hasField23 = true;
        result.field23_ = value;
        return this;
      }
      public Builder ClearField23() {
        PrepareBuilder();
        result.hasField23 = false;
        result.field23_ = false;
        return this;
      }
      
      public bool HasField206 {
        get { return result.hasField206; }
      }
      public bool Field206 {
        get { return result.Field206; }
        set { SetField206(value); }
      }
      public Builder SetField206(bool value) {
        PrepareBuilder();
        result.hasField206 = true;
        result.field206_ = value;
        return this;
      }
      public Builder ClearField206() {
        PrepareBuilder();
        result.hasField206 = false;
        result.field206_ = false;
        return this;
      }
      
      public bool HasField203 {
        get { return result.hasField203; }
      }
      [global::System.CLSCompliant(false)]
      public uint Field203 {
        get { return result.Field203; }
        set { SetField203(value); }
      }
      [global::System.CLSCompliant(false)]
      public Builder SetField203(uint value) {
        PrepareBuilder();
        result.hasField203 = true;
        result.field203_ = value;
        return this;
      }
      public Builder ClearField203() {
        PrepareBuilder();
        result.hasField203 = false;
        result.field203_ = 0;
        return this;
      }
      
      public bool HasField204 {
        get { return result.hasField204; }
      }
      public int Field204 {
        get { return result.Field204; }
        set { SetField204(value); }
      }
      public Builder SetField204(int value) {
        PrepareBuilder();
        result.hasField204 = true;
        result.field204_ = value;
        return this;
      }
      public Builder ClearField204() {
        PrepareBuilder();
        result.hasField204 = false;
        result.field204_ = 0;
        return this;
      }
      
      public bool HasField205 {
        get { return result.hasField205; }
      }
      public string Field205 {
        get { return result.Field205; }
        set { SetField205(value); }
      }
      public Builder SetField205(string value) {
        pb::ThrowHelper.ThrowIfNull(value, "value");
        PrepareBuilder();
        result.hasField205 = true;
        result.field205_ = value;
        return this;
      }
      public Builder ClearField205() {
        PrepareBuilder();
        result.hasField205 = false;
        result.field205_ = "";
        return this;
      }
      
      public bool HasField207 {
        get { return result.hasField207; }
      }
      [global::System.CLSCompliant(false)]
      public ulong Field207 {
        get { return result.Field207; }
        set { SetField207(value); }
      }
      [global::System.CLSCompliant(false)]
      public Builder SetField207(ulong value) {
        PrepareBuilder();
        result.hasField207 = true;
        result.field207_ = value;
        return this;
      }
      public Builder ClearField207() {
        PrepareBuilder();
        result.hasField207 = false;
        result.field207_ = 0UL;
        return this;
      }
      
      public bool HasField300 {
        get { return result.hasField300; }
      }
      [global::System.CLSCompliant(false)]
      public ulong Field300 {
        get { return result.Field300; }
        set { SetField300(value); }
      }
      [global::System.CLSCompliant(false)]
      public Builder SetField300(ulong value) {
        PrepareBuilder();
        result.hasField300 = true;
        result.field300_ = value;
        return this;
      }
      public Builder ClearField300() {
        PrepareBuilder();
        result.hasField300 = false;
        result.field300_ = 0UL;
        return this;
      }
    }
    static SpeedMessage1SubMessage() {
      object.ReferenceEquals(global::Google.ProtocolBuffers.TestProtos.UnitTestGoogleSpeedProtoFile.Descriptor, null);
    }
  }
  
  [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
  public sealed partial class SpeedMessage2 : pb::GeneratedMessage<SpeedMessage2, SpeedMessage2.Builder> {
    private SpeedMessage2() { }
    private static readonly SpeedMessage2 defaultInstance = new SpeedMessage2().MakeReadOnly();
    private static readonly string[] _speedMessage2FieldNames = new string[] { "field1", "field109", "field127", "field128", "field129", "field130", "field131", "field2", "field205", "field206", "field21", "field210", "field211", "field212", "field213", "field216", "field217", "field218", "field220", "field221", "field222", "field25", "field3", "field30", "field4", "field6", "field63", "field71", "field75", "group1" };
    private static readonly uint[] _speedMessage2FieldTags = new uint[] { 10, 872, 1018, 1026, 1032, 1040, 1048, 18, 1640, 1648, 168, 1680, 1688, 1696, 1704, 1728, 1736, 1744, 1760, 1768, 1781, 205, 24, 240, 32, 50, 504, 568, 600, 83 };
    public static SpeedMessage2 DefaultInstance {
      get { return defaultInstance; }
    }
    
    public override SpeedMessage2 DefaultInstanceForType {
      get { return DefaultInstance; }
    }
    
    protected override SpeedMessage2 ThisMessage {
      get { return this; }
    }
    
    public static pbd::MessageDescriptor Descriptor {
      get { return global::Google.ProtocolBuffers.TestProtos.UnitTestGoogleSpeedProtoFile.internal__static_unittest_google_speed_SpeedMessage2__Descriptor; }
    }
    
    protected override pb::FieldAccess.FieldAccessorTable<SpeedMessage2, SpeedMessage2.Builder> InternalFieldAccessors {
      get { return global::Google.ProtocolBuffers.TestProtos.UnitTestGoogleSpeedProtoFile.internal__static_unittest_google_speed_SpeedMessage2__FieldAccessorTable; }
    }
    
    #region Nested types
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    public static partial class Types {
      [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
      public sealed partial class Group1 : pb::GeneratedMessage<Group1, Group1.Builder> {
        private Group1() { }
        private static readonly Group1 defaultInstance = new Group1().MakeReadOnly();
        private static readonly string[] _group1FieldNames = new string[] { "field11", "field12", "field13", "field14", "field15", "field16", "field20", "field22", "field24", "field26", "field27", "field28", "field29", "field31", "field5", "field73" };
        private static readonly uint[] _group1FieldTags = new uint[] { 93, 98, 106, 114, 120, 130, 160, 178, 194, 213, 218, 224, 234, 250, 40, 584 };
        public static Group1 DefaultInstance {
          get { return defaultInstance; }
        }
        
        public override Group1 DefaultInstanceForType {
          get { return DefaultInstance; }
        }
        
        protected override Group1 ThisMessage {
          get { return this; }
        }
        
        public static pbd::MessageDescriptor Descriptor {
          get { return global::Google.ProtocolBuffers.TestProtos.UnitTestGoogleSpeedProtoFile.internal__static_unittest_google_speed_SpeedMessage2_Group1__Descriptor; }
        }
        
        protected override pb::FieldAccess.FieldAccessorTable<Group1, Group1.Builder> InternalFieldAccessors {
          get { return global::Google.ProtocolBuffers.TestProtos.UnitTestGoogleSpeedProtoFile.internal__static_unittest_google_speed_SpeedMessage2_Group1__FieldAccessorTable; }
        }
        
        public const int Field11FieldNumber = 11;
        private bool hasField11;
        private float field11_;
        public bool HasField11 {
          get { return hasField11; }
        }
        public float Field11 {
          get { return field11_; }
        }
        
        public const int Field26FieldNumber = 26;
        private bool hasField26;
        private float field26_;
        public bool HasField26 {
          get { return hasField26; }
        }
        public float Field26 {
          get { return field26_; }
        }
        
        public const int Field12FieldNumber = 12;
        private bool hasField12;
        private string field12_ = "";
        public bool HasField12 {
          get { return hasField12; }
        }
        public string Field12 {
          get { return field12_; }
        }
        
        public const int Field13FieldNumber = 13;
        private bool hasField13;
        private string field13_ = "";
        public bool HasField13 {
          get { return hasField13; }
        }
        public string Field13 {
          get { return field13_; }
        }
        
        public const int Field14FieldNumber = 14;
        private pbc::PopsicleList<string> field14_ = new pbc::PopsicleList<string>();
        public scg::IList<string> Field14List {
          get { return pbc::Lists.AsReadOnly(field14_); }
        }
        public int Field14Count {
          get { return field14_.Count; }
        }
        public string GetField14(int index) {
          return field14_[index];
        }
        
        public const int Field15FieldNumber = 15;
        private bool hasField15;
        private ulong field15_;
        public bool HasField15 {
          get { return hasField15; }
        }
        [global::System.CLSCompliant(false)]
        public ulong Field15 {
          get { return field15_; }
        }
        
        public const int Field5FieldNumber = 5;
        private bool hasField5;
        private int field5_;
        public bool HasField5 {
          get { return hasField5; }
        }
        public int Field5 {
          get { return field5_; }
        }
        
        public const int Field27FieldNumber = 27;
        private bool hasField27;
        private string field27_ = "";
        public bool HasField27 {
          get { return hasField27; }
        }
        public string Field27 {
          get { return field27_; }
        }
        
        public const int Field28FieldNumber = 28;
        private bool hasField28;
        private int field28_;
        public bool HasField28 {
          get { return hasField28; }
        }
        public int Field28 {
          get { return field28_; }
        }
        
        public const int Field29FieldNumber = 29;
        private bool hasField29;
        private string field29_ = "";
        public bool HasField29 {
          get { return hasField29; }
        }
        public string Field29 {
          get { return field29_; }
        }
        
        public const int Field16FieldNumber = 16;
        private bool hasField16;
        private string field16_ = "";
        public bool HasField16 {
          get { return hasField16; }
        }
        public string Field16 {
          get { return field16_; }
        }
        
        public const int Field22FieldNumber = 22;
        private pbc::PopsicleList<string> field22_ = new pbc::PopsicleList<string>();
        public scg::IList<string> Field22List {
          get { return pbc::Lists.AsReadOnly(field22_); }
        }
        public int Field22Count {
          get { return field22_.Count; }
        }
        public string GetField22(int index) {
          return field22_[index];
        }
        
        public const int Field73FieldNumber = 73;
        private pbc::PopsicleList<int> field73_ = new pbc::PopsicleList<int>();
        public scg::IList<int> Field73List {
          get { return pbc::Lists.AsReadOnly(field73_); }
        }
        public int Field73Count {
          get { return field73_.Count; }
        }
        public int GetField73(int index) {
          return field73_[index];
        }
        
        public const int Field20FieldNumber = 20;
        private bool hasField20;
        private int field20_;
        public bool HasField20 {
          get { return hasField20; }
        }
        public int Field20 {
          get { return field20_; }
        }
        
        public const int Field24FieldNumber = 24;
        private bool hasField24;
        private string field24_ = "";
        public bool HasField24 {
          get { return hasField24; }
        }
        public string Field24 {
          get { return field24_; }
        }
        
        public const int Field31FieldNumber = 31;
        private bool hasField31;
        private global::Google.ProtocolBuffers.TestProtos.SpeedMessage2GroupedMessage field31_;
        public bool HasField31 {
          get { return hasField31; }
        }
        public global::Google.ProtocolBuffers.TestProtos.SpeedMessage2GroupedMessage Field31 {
          get { return field31_ ?? global::Google.ProtocolBuffers.TestProtos.SpeedMessage2GroupedMessage.DefaultInstance; }
        }
        
        public override bool IsInitialized {
          get {
            if (!hasField11) return false;
            if (!hasField15) return false;
            return true;
          }
        }
        
        public override void WriteTo(pb::ICodedOutputStream output) {
          int size = SerializedSize;
          string[] field_names = _group1FieldNames;
          if (hasField5) {
            output.WriteInt32(5, field_names[14], Field5);
          }
          if (hasField11) {
            output.WriteFloat(11, field_names[0], Field11);
          }
          if (hasField12) {
            output.WriteString(12, field_names[1], Field12);
          }
          if (hasField13) {
            output.WriteString(13, field_names[2], Field13);
          }
          if (field14_.Count > 0) {
            output.WriteStringArray(14, field_names[3], field14_);
          }
          if (hasField15) {
            output.WriteUInt64(15, field_names[4], Field15);
          }
          if (hasField16) {
            output.WriteString(16, field_names[5], Field16);
          }
          if (hasField20) {
            output.WriteInt32(20, field_names[6], Field20);
          }
          if (field22_.Count > 0) {
            output.WriteStringArray(22, field_names[7], field22_);
          }
          if (hasField24) {
            output.WriteString(24, field_names[8], Field24);
          }
          if (hasField26) {
            output.WriteFloat(26, field_names[9], Field26);
          }
          if (hasField27) {
            output.WriteString(27, field_names[10], Field27);
          }
          if (hasField28) {
            output.WriteInt32(28, field_names[11], Field28);
          }
          if (hasField29) {
            output.WriteString(29, field_names[12], Field29);
          }
          if (hasField31) {
            output.WriteMessage(31, field_names[13], Field31);
          }
          if (field73_.Count > 0) {
            output.WriteInt32Array(73, field_names[15], field73_);
          }
          UnknownFields.WriteTo(output);
        }
        
        private int memoizedSerializedSize = -1;
        public override int SerializedSize {
          get {
            int size = memoizedSerializedSize;
            if (size != -1) return size;
            
            size = 0;
            if (hasField11) {
              size += pb::CodedOutputStream.ComputeFloatSize(11, Field11);
            }
            if (hasField26) {
              size += pb::CodedOutputStream.ComputeFloatSize(26, Field26);
            }
            if (hasField12) {
              size += pb::CodedOutputStream.ComputeStringSize(12, Field12);
            }
            if (hasField13) {
              size += pb::CodedOutputStream.ComputeStringSize(13, Field13);
            }
            {
              int dataSize = 0;
              foreach (string element in Field14List) {
                dataSize += pb::CodedOutputStream.ComputeStringSizeNoTag(element);
              }
              size += dataSize;
              size += 1 * field14_.Count;
            }
            if (hasField15) {
              size += pb::CodedOutputStream.ComputeUInt64Size(15, Field15);
            }
            if (hasField5) {
              size += pb::CodedOutputStream.ComputeInt32Size(5, Field5);
            }
            if (hasField27) {
              size += pb::CodedOutputStream.ComputeStringSize(27, Field27);
            }
            if (hasField28) {
              size += pb::CodedOutputStream.ComputeInt32Size(28, Field28);
            }
            if (hasField29) {
              size += pb::CodedOutputStream.ComputeStringSize(29, Field29);
            }
            if (hasField16) {
              size += pb::CodedOutputStream.ComputeStringSize(16, Field16);
            }
            {
              int dataSize = 0;
              foreach (string element in Field22List) {
                dataSize += pb::CodedOutputStream.ComputeStringSizeNoTag(element);
              }
              size += dataSize;
              size += 2 * field22_.Count;
            }
            {
              int dataSize = 0;
              foreach (int element in Field73List) {
                dataSize += pb::CodedOutputStream.ComputeInt32SizeNoTag(element);
              }
              size += dataSize;
              size += 2 * field73_.Count;
            }
            if (hasField20) {
              size += pb::CodedOutputStream.ComputeInt32Size(20, Field20);
            }
            if (hasField24) {
              size += pb::CodedOutputStream.ComputeStringSize(24, Field24);
            }
            if (hasField31) {
              size += pb::CodedOutputStream.ComputeMessageSize(31, Field31);
            }
            size += UnknownFields.SerializedSize;
            memoizedSerializedSize = size;
            return size;
          }
        }
        
        public static Group1 ParseFrom(pb::ByteString data) {
          return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
        }
        public static Group1 ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {
          return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
        }
        public static Group1 ParseFrom(byte[] data) {
          return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
        }
        public static Group1 ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {
          return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
        }
        public static Group1 ParseFrom(global::System.IO.Stream input) {
          return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
        }
        public static Group1 ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
          return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
        }
        public static Group1 ParseDelimitedFrom(global::System.IO.Stream input) {
          return CreateBuilder().MergeDelimitedFrom(input).BuildParsed();
        }
        public static Group1 ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
          return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed();
        }
        public static Group1 ParseFrom(pb::ICodedInputStream input) {
          return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
        }
        public static Group1 ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
          return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
        }
        private Group1 MakeReadOnly() {
          field14_.MakeReadOnly();
          field22_.MakeReadOnly();
          field73_.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(Group1 prototype) {
          return new Builder(prototype);
        }
        
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        public sealed partial class Builder : pb::GeneratedBuilder<Group1, Builder> {
          protected override Builder ThisBuilder {
            get { return this; }
          }
          public Builder() {
            result = DefaultInstance;
            resultIsReadOnly = true;
          }
          internal Builder(Group1 cloneFrom) {
            result = cloneFrom;
            resultIsReadOnly = true;
          }
          
          private bool resultIsReadOnly;
          private Group1 result;
          
          private Group1 PrepareBuilder() {
            if (resultIsReadOnly) {
              Group1 original = result;
              result = new Group1();
              resultIsReadOnly = false;
              MergeFrom(original);
            }
            return result;
          }
          
          public override bool IsInitialized {
            get { return result.IsInitialized; }
          }
          
          protected override Group1 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.SpeedMessage2.Types.Group1.Descriptor; }
          }
          
          public override Group1 DefaultInstanceForType {
            get { return global::Google.ProtocolBuffers.TestProtos.SpeedMessage2.Types.Group1.DefaultInstance; }
          }
          
          public override Group1 BuildPartial() {
            if (resultIsReadOnly) {
              return result;
            }
            resultIsReadOnly = true;
            return result.MakeReadOnly();
          }
          
          public override Builder MergeFrom(pb::IMessage other) {
            if (other is Group1) {
              return MergeFrom((Group1) other);
            } else {
              base.MergeFrom(other);
              return this;
            }
          }
          
          public override Builder MergeFrom(Group1 other) {
            if (other == global::Google.ProtocolBuffers.TestProtos.SpeedMessage2.Types.Group1.DefaultInstance) return this;
            PrepareBuilder();
            if (other.HasField11) {
              Field11 = other.Field11;
            }
            if (other.HasField26) {
              Field26 = other.Field26;
            }
            if (other.HasField12) {
              Field12 = other.Field12;
            }
            if (other.HasField13) {
              Field13 = other.Field13;
            }
            if (other.field14_.Count != 0) {
              result.field14_.Add(other.field14_);
            }
            if (other.HasField15) {
              Field15 = other.Field15;
            }
            if (other.HasField5) {
              Field5 = other.Field5;
            }
            if (other.HasField27) {
              Field27 = other.Field27;
            }
            if (other.HasField28) {
              Field28 = other.Field28;
            }
            if (other.HasField29) {
              Field29 = other.Field29;
            }
            if (other.HasField16) {
              Field16 = other.Field16;
            }
            if (other.field22_.Count != 0) {
              result.field22_.Add(other.field22_);
            }
            if (other.field73_.Count != 0) {
              result.field73_.Add(other.field73_);
            }
            if (other.HasField20) {
              Field20 = other.Field20;
            }
            if (other.HasField24) {
              Field24 = other.Field24;
            }
            if (other.HasField31) {
              MergeField31(other.Field31);
            }
            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(_group1FieldNames, field_name, global::System.StringComparer.Ordinal);
                if(field_ordinal >= 0)
                  tag = _group1FieldTags[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 40: {
                  result.hasField5 = input.ReadInt32(ref result.field5_);
                  break;
                }
                case 93: {
                  result.hasField11 = input.ReadFloat(ref result.field11_);
                  break;
                }
                case 98: {
                  result.hasField12 = input.ReadString(ref result.field12_);
                  break;
                }
                case 106: {
                  result.hasField13 = input.ReadString(ref result.field13_);
                  break;
                }
                case 114: {
                  input.ReadStringArray(tag, field_name, result.field14_);
                  break;
                }
                case 120: {
                  result.hasField15 = input.ReadUInt64(ref result.field15_);
                  break;
                }
                case 130: {
                  result.hasField16 = input.ReadString(ref result.field16_);
                  break;
                }
                case 160: {
                  result.hasField20 = input.ReadInt32(ref result.field20_);
                  break;
                }
                case 178: {
                  input.ReadStringArray(tag, field_name, result.field22_);
                  break;
                }
                case 194: {
                  result.hasField24 = input.ReadString(ref result.field24_);
                  break;
                }
                case 213: {
                  result.hasField26 = input.ReadFloat(ref result.field26_);
                  break;
                }
                case 218: {
                  result.hasField27 = input.ReadString(ref result.field27_);
                  break;
                }
                case 224: {
                  result.hasField28 = input.ReadInt32(ref result.field28_);
                  break;
                }
                case 234: {
                  result.hasField29 = input.ReadString(ref result.field29_);
                  break;
                }
                case 250: {
                  global::Google.ProtocolBuffers.TestProtos.SpeedMessage2GroupedMessage.Builder subBuilder = global::Google.ProtocolBuffers.TestProtos.SpeedMessage2GroupedMessage.CreateBuilder();
                  if (result.hasField31) {
                    subBuilder.MergeFrom(Field31);
                  }
                  input.ReadMessage(subBuilder, extensionRegistry);
                  Field31 = subBuilder.BuildPartial();
                  break;
                }
                case 586:
                case 584: {
                  input.ReadInt32Array(tag, field_name, result.field73_);
                  break;
                }
              }
            }
            
            if (unknownFields != null) {
              this.UnknownFields = unknownFields.Build();
            }
            return this;
          }
          
          
          public bool HasField11 {
            get { return result.hasField11; }
          }
          public float Field11 {
            get { return result.Field11; }
            set { SetField11(value); }
          }
          public Builder SetField11(float value) {
            PrepareBuilder();
            result.hasField11 = true;
            result.field11_ = value;
            return this;
          }
          public Builder ClearField11() {
            PrepareBuilder();
            result.hasField11 = false;
            result.field11_ = 0F;
            return this;
          }
          
          public bool HasField26 {
            get { return result.hasField26; }
          }
          public float Field26 {
            get { return result.Field26; }
            set { SetField26(value); }
          }
          public Builder SetField26(float value) {
            PrepareBuilder();
            result.hasField26 = true;
            result.field26_ = value;
            return this;
          }
          public Builder ClearField26() {
            PrepareBuilder();
            result.hasField26 = false;
            result.field26_ = 0F;
            return this;
          }
          
          public bool HasField12 {
            get { return result.hasField12; }
          }
          public string Field12 {
            get { return result.Field12; }
            set { SetField12(value); }
          }
          public Builder SetField12(string value) {
            pb::ThrowHelper.ThrowIfNull(value, "value");
            PrepareBuilder();
            result.hasField12 = true;
            result.field12_ = value;
            return this;
          }
          public Builder ClearField12() {
            PrepareBuilder();
            result.hasField12 = false;
            result.field12_ = "";
            return this;
          }
          
          public bool HasField13 {
            get { return result.hasField13; }
          }
          public string Field13 {
            get { return result.Field13; }
            set { SetField13(value); }
          }
          public Builder SetField13(string value) {
            pb::ThrowHelper.ThrowIfNull(value, "value");
            PrepareBuilder();
            result.hasField13 = true;
            result.field13_ = value;
            return this;
          }
          public Builder ClearField13() {
            PrepareBuilder();
            result.hasField13 = false;
            result.field13_ = "";
            return this;
          }
          
          public pbc::IPopsicleList<string> Field14List {
            get { return PrepareBuilder().field14_; }
          }
          public int Field14Count {
            get { return result.Field14Count; }
          }
          public string GetField14(int index) {
            return result.GetField14(index);
          }
          public Builder SetField14(int index, string value) {
            pb::ThrowHelper.ThrowIfNull(value, "value");
            PrepareBuilder();
            result.field14_[index] = value;
            return this;
          }
          public Builder AddField14(string value) {
            pb::ThrowHelper.ThrowIfNull(value, "value");
            PrepareBuilder();
            result.field14_.Add(value);
            return this;
          }
          public Builder AddRangeField14(scg::IEnumerable<string> values) {
            PrepareBuilder();
            result.field14_.Add(values);
            return this;
          }
          public Builder ClearField14() {
            PrepareBuilder();
            result.field14_.Clear();
            return this;
          }
          
          public bool HasField15 {
            get { return result.hasField15; }
          }
          [global::System.CLSCompliant(false)]
          public ulong Field15 {
            get { return result.Field15; }
            set { SetField15(value); }
          }
          [global::System.CLSCompliant(false)]
          public Builder SetField15(ulong value) {
            PrepareBuilder();
            result.hasField15 = true;
            result.field15_ = value;
            return this;
          }
          public Builder ClearField15() {
            PrepareBuilder();
            result.hasField15 = false;
            result.field15_ = 0UL;
            return this;
          }
          
          public bool HasField5 {
            get { return result.hasField5; }
          }
          public int Field5 {
            get { return result.Field5; }
            set { SetField5(value); }
          }
          public Builder SetField5(int value) {
            PrepareBuilder();
            result.hasField5 = true;
            result.field5_ = value;
            return this;
          }
          public Builder ClearField5() {
            PrepareBuilder();
            result.hasField5 = false;
            result.field5_ = 0;
            return this;
          }
          
          public bool HasField27 {
            get { return result.hasField27; }
          }
          public string Field27 {
            get { return result.Field27; }
            set { SetField27(value); }
          }
          public Builder SetField27(string value) {
            pb::ThrowHelper.ThrowIfNull(value, "value");
            PrepareBuilder();
            result.hasField27 = true;
            result.field27_ = value;
            return this;
          }
          public Builder ClearField27() {
            PrepareBuilder();
            result.hasField27 = false;
            result.field27_ = "";
            return this;
          }
          
          public bool HasField28 {
            get { return result.hasField28; }
          }
          public int Field28 {
            get { return result.Field28; }
            set { SetField28(value); }
          }
          public Builder SetField28(int value) {
            PrepareBuilder();
            result.hasField28 = true;
            result.field28_ = value;
            return this;
          }
          public Builder ClearField28() {
            PrepareBuilder();
            result.hasField28 = false;
            result.field28_ = 0;
            return this;
          }
          
          public bool HasField29 {
            get { return result.hasField29; }
          }
          public string Field29 {
            get { return result.Field29; }
            set { SetField29(value); }
          }
          public Builder SetField29(string value) {
            pb::ThrowHelper.ThrowIfNull(value, "value");
            PrepareBuilder();
            result.hasField29 = true;
            result.field29_ = value;
            return this;
          }
          public Builder ClearField29() {
            PrepareBuilder();
            result.hasField29 = false;
            result.field29_ = "";
            return this;
          }
          
          public bool HasField16 {
            get { return result.hasField16; }
          }
          public string Field16 {
            get { return result.Field16; }
            set { SetField16(value); }
          }
          public Builder SetField16(string value) {
            pb::ThrowHelper.ThrowIfNull(value, "value");
            PrepareBuilder();
            result.hasField16 = true;
            result.field16_ = value;
            return this;
          }
          public Builder ClearField16() {
            PrepareBuilder();
            result.hasField16 = false;
            result.field16_ = "";
            return this;
          }
          
          public pbc::IPopsicleList<string> Field22List {
            get { return PrepareBuilder().field22_; }
          }
          public int Field22Count {
            get { return result.Field22Count; }
          }
          public string GetField22(int index) {
            return result.GetField22(index);
          }
          public Builder SetField22(int index, string value) {
            pb::ThrowHelper.ThrowIfNull(value, "value");
            PrepareBuilder();
            result.field22_[index] = value;
            return this;
          }
          public Builder AddField22(string value) {
            pb::ThrowHelper.ThrowIfNull(value, "value");
            PrepareBuilder();
            result.field22_.Add(value);
            return this;
          }
          public Builder AddRangeField22(scg::IEnumerable<string> values) {
            PrepareBuilder();
            result.field22_.Add(values);
            return this;
          }
          public Builder ClearField22() {
            PrepareBuilder();
            result.field22_.Clear();
            return this;
          }
          
          public pbc::IPopsicleList<int> Field73List {
            get { return PrepareBuilder().field73_; }
          }
          public int Field73Count {
            get { return result.Field73Count; }
          }
          public int GetField73(int index) {
            return result.GetField73(index);
          }
          public Builder SetField73(int index, int value) {
            PrepareBuilder();
            result.field73_[index] = value;
            return this;
          }
          public Builder AddField73(int value) {
            PrepareBuilder();
            result.field73_.Add(value);
            return this;
          }
          public Builder AddRangeField73(scg::IEnumerable<int> values) {
            PrepareBuilder();
            result.field73_.Add(values);
            return this;
          }
          public Builder ClearField73() {
            PrepareBuilder();
            result.field73_.Clear();
            return this;
          }
          
          public bool HasField20 {
            get { return result.hasField20; }
          }
          public int Field20 {
            get { return result.Field20; }
            set { SetField20(value); }
          }
          public Builder SetField20(int value) {
            PrepareBuilder();
            result.hasField20 = true;
            result.field20_ = value;
            return this;
          }
          public Builder ClearField20() {
            PrepareBuilder();
            result.hasField20 = false;
            result.field20_ = 0;
            return this;
          }
          
          public bool HasField24 {
            get { return result.hasField24; }
          }
          public string Field24 {
            get { return result.Field24; }
            set { SetField24(value); }
          }
          public Builder SetField24(string value) {
            pb::ThrowHelper.ThrowIfNull(value, "value");
            PrepareBuilder();
            result.hasField24 = true;
            result.field24_ = value;
            return this;
          }
          public Builder ClearField24() {
            PrepareBuilder();
            result.hasField24 = false;
            result.field24_ = "";
            return this;
          }
          
          public bool HasField31 {
           get { return result.hasField31; }
          }
          public global::Google.ProtocolBuffers.TestProtos.SpeedMessage2GroupedMessage Field31 {
            get { return result.Field31; }
            set { SetField31(value); }
          }
          public Builder SetField31(global::Google.ProtocolBuffers.TestProtos.SpeedMessage2GroupedMessage value) {
            pb::ThrowHelper.ThrowIfNull(value, "value");
            PrepareBuilder();
            result.hasField31 = true;
            result.field31_ = value;
            return this;
          }
          public Builder SetField31(global::Google.ProtocolBuffers.TestProtos.SpeedMessage2GroupedMessage.Builder builderForValue) {
            pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue");
            PrepareBuilder();
            result.hasField31 = true;
            result.field31_ = builderForValue.Build();
            return this;
          }
          public Builder MergeField31(global::Google.ProtocolBuffers.TestProtos.SpeedMessage2GroupedMessage value) {
            pb::ThrowHelper.ThrowIfNull(value, "value");
            PrepareBuilder();
            if (result.hasField31 &&
                result.field31_ != global::Google.ProtocolBuffers.TestProtos.SpeedMessage2GroupedMessage.DefaultInstance) {
                result.field31_ = global::Google.ProtocolBuffers.TestProtos.SpeedMessage2GroupedMessage.CreateBuilder(result.field31_).MergeFrom(value).BuildPartial();
            } else {
              result.field31_ = value;
            }
            result.hasField31 = true;
            return this;
          }
          public Builder ClearField31() {
            PrepareBuilder();
            result.hasField31 = false;
            result.field31_ = null;
            return this;
          }
        }
        static Group1() {
          object.ReferenceEquals(global::Google.ProtocolBuffers.TestProtos.UnitTestGoogleSpeedProtoFile.Descriptor, null);
        }
      }
      
    }
    #endregion
    
    public const int Field1FieldNumber = 1;
    private bool hasField1;
    private string field1_ = "";
    public bool HasField1 {
      get { return hasField1; }
    }
    public string Field1 {
      get { return field1_; }
    }
    
    public const int Field3FieldNumber = 3;
    private bool hasField3;
    private long field3_;
    public bool HasField3 {
      get { return hasField3; }
    }
    public long Field3 {
      get { return field3_; }
    }
    
    public const int Field4FieldNumber = 4;
    private bool hasField4;
    private long field4_;
    public bool HasField4 {
      get { return hasField4; }
    }
    public long Field4 {
      get { return field4_; }
    }
    
    public const int Field30FieldNumber = 30;
    private bool hasField30;
    private long field30_;
    public bool HasField30 {
      get { return hasField30; }
    }
    public long Field30 {
      get { return field30_; }
    }
    
    public const int Field75FieldNumber = 75;
    private bool hasField75;
    private bool field75_;
    public bool HasField75 {
      get { return hasField75; }
    }
    public bool Field75 {
      get { return field75_; }
    }
    
    public const int Field6FieldNumber = 6;
    private bool hasField6;
    private string field6_ = "";
    public bool HasField6 {
      get { return hasField6; }
    }
    public string Field6 {
      get { return field6_; }
    }
    
    public const int Field2FieldNumber = 2;
    private bool hasField2;
    private pb::ByteString field2_ = pb::ByteString.Empty;
    public bool HasField2 {
      get { return hasField2; }
    }
    public pb::ByteString Field2 {
      get { return field2_; }
    }
    
    public const int Field21FieldNumber = 21;
    private bool hasField21;
    private int field21_;
    public bool HasField21 {
      get { return hasField21; }
    }
    public int Field21 {
      get { return field21_; }
    }
    
    public const int Field71FieldNumber = 71;
    private bool hasField71;
    private int field71_;
    public bool HasField71 {
      get { return hasField71; }
    }
    public int Field71 {
      get { return field71_; }
    }
    
    public const int Field25FieldNumber = 25;
    private bool hasField25;
    private float field25_;
    public bool HasField25 {
      get { return hasField25; }
    }
    public float Field25 {
      get { return field25_; }
    }
    
    public const int Field109FieldNumber = 109;
    private bool hasField109;
    private int field109_;
    public bool HasField109 {
      get { return hasField109; }
    }
    public int Field109 {
      get { return field109_; }
    }
    
    public const int Field210FieldNumber = 210;
    private bool hasField210;
    private int field210_;
    public bool HasField210 {
      get { return hasField210; }
    }
    public int Field210 {
      get { return field210_; }
    }
    
    public const int Field211FieldNumber = 211;
    private bool hasField211;
    private int field211_;
    public bool HasField211 {
      get { return hasField211; }
    }
    public int Field211 {
      get { return field211_; }
    }
    
    public const int Field212FieldNumber = 212;
    private bool hasField212;
    private int field212_;
    public bool HasField212 {
      get { return hasField212; }
    }
    public int Field212 {
      get { return field212_; }
    }
    
    public const int Field213FieldNumber = 213;
    private bool hasField213;
    private int field213_;
    public bool HasField213 {
      get { return hasField213; }
    }
    public int Field213 {
      get { return field213_; }
    }
    
    public const int Field216FieldNumber = 216;
    private bool hasField216;
    private int field216_;
    public bool HasField216 {
      get { return hasField216; }
    }
    public int Field216 {
      get { return field216_; }
    }
    
    public const int Field217FieldNumber = 217;
    private bool hasField217;
    private int field217_;
    public bool HasField217 {
      get { return hasField217; }
    }
    public int Field217 {
      get { return field217_; }
    }
    
    public const int Field218FieldNumber = 218;
    private bool hasField218;
    private int field218_;
    public bool HasField218 {
      get { return hasField218; }
    }
    public int Field218 {
      get { return field218_; }
    }
    
    public const int Field220FieldNumber = 220;
    private bool hasField220;
    private int field220_;
    public bool HasField220 {
      get { return hasField220; }
    }
    public int Field220 {
      get { return field220_; }
    }
    
    public const int Field221FieldNumber = 221;
    private bool hasField221;
    private int field221_;
    public bool HasField221 {
      get { return hasField221; }
    }
    public int Field221 {
      get { return field221_; }
    }
    
    public const int Field222FieldNumber = 222;
    private bool hasField222;
    private float field222_;
    public bool HasField222 {
      get { return hasField222; }
    }
    public float Field222 {
      get { return field222_; }
    }
    
    public const int Field63FieldNumber = 63;
    private bool hasField63;
    private int field63_;
    public bool HasField63 {
      get { return hasField63; }
    }
    public int Field63 {
      get { return field63_; }
    }
    
    public const int Group1FieldNumber = 10;
    private pbc::PopsicleList<global::Google.ProtocolBuffers.TestProtos.SpeedMessage2.Types.Group1> group1_ = new pbc::PopsicleList<global::Google.ProtocolBuffers.TestProtos.SpeedMessage2.Types.Group1>();
    public scg::IList<global::Google.ProtocolBuffers.TestProtos.SpeedMessage2.Types.Group1> Group1List {
      get { return group1_; }
    }
    public int Group1Count {
      get { return group1_.Count; }
    }
    public global::Google.ProtocolBuffers.TestProtos.SpeedMessage2.Types.Group1 GetGroup1(int index) {
      return group1_[index];
    }
    
    public const int Field128FieldNumber = 128;
    private pbc::PopsicleList<string> field128_ = new pbc::PopsicleList<string>();
    public scg::IList<string> Field128List {
      get { return pbc::Lists.AsReadOnly(field128_); }
    }
    public int Field128Count {
      get { return field128_.Count; }
    }
    public string GetField128(int index) {
      return field128_[index];
    }
    
    public const int Field131FieldNumber = 131;
    private bool hasField131;
    private long field131_;
    public bool HasField131 {
      get { return hasField131; }
    }
    public long Field131 {
      get { return field131_; }
    }
    
    public const int Field127FieldNumber = 127;
    private pbc::PopsicleList<string> field127_ = new pbc::PopsicleList<string>();
    public scg::IList<string> Field127List {
      get { return pbc::Lists.AsReadOnly(field127_); }
    }
    public int Field127Count {
      get { return field127_.Count; }
    }
    public string GetField127(int index) {
      return field127_[index];
    }
    
    public const int Field129FieldNumber = 129;
    private bool hasField129;
    private int field129_;
    public bool HasField129 {
      get { return hasField129; }
    }
    public int Field129 {
      get { return field129_; }
    }
    
    public const int Field130FieldNumber = 130;
    private pbc::PopsicleList<long> field130_ = new pbc::PopsicleList<long>();
    public scg::IList<long> Field130List {
      get { return pbc::Lists.AsReadOnly(field130_); }
    }
    public int Field130Count {
      get { return field130_.Count; }
    }
    public long GetField130(int index) {
      return field130_[index];
    }
    
    public const int Field205FieldNumber = 205;
    private bool hasField205;
    private bool field205_;
    public bool HasField205 {
      get { return hasField205; }
    }
    public bool Field205 {
      get { return field205_; }
    }
    
    public const int Field206FieldNumber = 206;
    private bool hasField206;
    private bool field206_;
    public bool HasField206 {
      get { return hasField206; }
    }
    public bool Field206 {
      get { return field206_; }
    }
    
    public override bool IsInitialized {
      get {
        return true;
      }
    }
    
    public override void WriteTo(pb::ICodedOutputStream output) {
      int size = SerializedSize;
      string[] field_names = _speedMessage2FieldNames;
      if (hasField1) {
        output.WriteString(1, field_names[0], Field1);
      }
      if (hasField2) {
        output.WriteBytes(2, field_names[7], Field2);
      }
      if (hasField3) {
        output.WriteInt64(3, field_names[22], Field3);
      }
      if (hasField4) {
        output.WriteInt64(4, field_names[24], Field4);
      }
      if (hasField6) {
        output.WriteString(6, field_names[25], Field6);
      }
      if (group1_.Count > 0) {
        output.WriteGroupArray(10, field_names[29], group1_);
      }
      if (hasField21) {
        output.WriteInt32(21, field_names[10], Field21);
      }
      if (hasField25) {
        output.WriteFloat(25, field_names[21], Field25);
      }
      if (hasField30) {
        output.WriteInt64(30, field_names[23], Field30);
      }
      if (hasField63) {
        output.WriteInt32(63, field_names[26], Field63);
      }
      if (hasField71) {
        output.WriteInt32(71, field_names[27], Field71);
      }
      if (hasField75) {
        output.WriteBool(75, field_names[28], Field75);
      }
      if (hasField109) {
        output.WriteInt32(109, field_names[1], Field109);
      }
      if (field127_.Count > 0) {
        output.WriteStringArray(127, field_names[2], field127_);
      }
      if (field128_.Count > 0) {
        output.WriteStringArray(128, field_names[3], field128_);
      }
      if (hasField129) {
        output.WriteInt32(129, field_names[4], Field129);
      }
      if (field130_.Count > 0) {
        output.WriteInt64Array(130, field_names[5], field130_);
      }
      if (hasField131) {
        output.WriteInt64(131, field_names[6], Field131);
      }
      if (hasField205) {
        output.WriteBool(205, field_names[8], Field205);
      }
      if (hasField206) {
        output.WriteBool(206, field_names[9], Field206);
      }
      if (hasField210) {
        output.WriteInt32(210, field_names[11], Field210);
      }
      if (hasField211) {
        output.WriteInt32(211, field_names[12], Field211);
      }
      if (hasField212) {
        output.WriteInt32(212, field_names[13], Field212);
      }
      if (hasField213) {
        output.WriteInt32(213, field_names[14], Field213);
      }
      if (hasField216) {
        output.WriteInt32(216, field_names[15], Field216);
      }
      if (hasField217) {
        output.WriteInt32(217, field_names[16], Field217);
      }
      if (hasField218) {
        output.WriteInt32(218, field_names[17], Field218);
      }
      if (hasField220) {
        output.WriteInt32(220, field_names[18], Field220);
      }
      if (hasField221) {
        output.WriteInt32(221, field_names[19], Field221);
      }
      if (hasField222) {
        output.WriteFloat(222, field_names[20], Field222);
      }
      UnknownFields.WriteTo(output);
    }
    
    private int memoizedSerializedSize = -1;
    public override int SerializedSize {
      get {
        int size = memoizedSerializedSize;
        if (size != -1) return size;
        
        size = 0;
        if (hasField1) {
          size += pb::CodedOutputStream.ComputeStringSize(1, Field1);
        }
        if (hasField3) {
          size += pb::CodedOutputStream.ComputeInt64Size(3, Field3);
        }
        if (hasField4) {
          size += pb::CodedOutputStream.ComputeInt64Size(4, Field4);
        }
        if (hasField30) {
          size += pb::CodedOutputStream.ComputeInt64Size(30, Field30);
        }
        if (hasField75) {
          size += pb::CodedOutputStream.ComputeBoolSize(75, Field75);
        }
        if (hasField6) {
          size += pb::CodedOutputStream.ComputeStringSize(6, Field6);
        }
        if (hasField2) {
          size += pb::CodedOutputStream.ComputeBytesSize(2, Field2);
        }
        if (hasField21) {
          size += pb::CodedOutputStream.ComputeInt32Size(21, Field21);
        }
        if (hasField71) {
          size += pb::CodedOutputStream.ComputeInt32Size(71, Field71);
        }
        if (hasField25) {
          size += pb::CodedOutputStream.ComputeFloatSize(25, Field25);
        }
        if (hasField109) {
          size += pb::CodedOutputStream.ComputeInt32Size(109, Field109);
        }
        if (hasField210) {
          size += pb::CodedOutputStream.ComputeInt32Size(210, Field210);
        }
        if (hasField211) {
          size += pb::CodedOutputStream.ComputeInt32Size(211, Field211);
        }
        if (hasField212) {
          size += pb::CodedOutputStream.ComputeInt32Size(212, Field212);
        }
        if (hasField213) {
          size += pb::CodedOutputStream.ComputeInt32Size(213, Field213);
        }
        if (hasField216) {
          size += pb::CodedOutputStream.ComputeInt32Size(216, Field216);
        }
        if (hasField217) {
          size += pb::CodedOutputStream.ComputeInt32Size(217, Field217);
        }
        if (hasField218) {
          size += pb::CodedOutputStream.ComputeInt32Size(218, Field218);
        }
        if (hasField220) {
          size += pb::CodedOutputStream.ComputeInt32Size(220, Field220);
        }
        if (hasField221) {
          size += pb::CodedOutputStream.ComputeInt32Size(221, Field221);
        }
        if (hasField222) {
          size += pb::CodedOutputStream.ComputeFloatSize(222, Field222);
        }
        if (hasField63) {
          size += pb::CodedOutputStream.ComputeInt32Size(63, Field63);
        }
        foreach (global::Google.ProtocolBuffers.TestProtos.SpeedMessage2.Types.Group1 element in Group1List) {
          size += pb::CodedOutputStream.ComputeGroupSize(10, element);
        }
        {
          int dataSize = 0;
          foreach (string element in Field128List) {
            dataSize += pb::CodedOutputStream.ComputeStringSizeNoTag(element);
          }
          size += dataSize;
          size += 2 * field128_.Count;
        }
        if (hasField131) {
          size += pb::CodedOutputStream.ComputeInt64Size(131, Field131);
        }
        {
          int dataSize = 0;
          foreach (string element in Field127List) {
            dataSize += pb::CodedOutputStream.ComputeStringSizeNoTag(element);
          }
          size += dataSize;
          size += 2 * field127_.Count;
        }
        if (hasField129) {
          size += pb::CodedOutputStream.ComputeInt32Size(129, Field129);
        }
        {
          int dataSize = 0;
          foreach (long element in Field130List) {
            dataSize += pb::CodedOutputStream.ComputeInt64SizeNoTag(element);
          }
          size += dataSize;
          size += 2 * field130_.Count;
        }
        if (hasField205) {
          size += pb::CodedOutputStream.ComputeBoolSize(205, Field205);
        }
        if (hasField206) {
          size += pb::CodedOutputStream.ComputeBoolSize(206, Field206);
        }
        size += UnknownFields.SerializedSize;
        memoizedSerializedSize = size;
        return size;
      }
    }
    
    public static SpeedMessage2 ParseFrom(pb::ByteString data) {
      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
    }
    public static SpeedMessage2 ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
    }
    public static SpeedMessage2 ParseFrom(byte[] data) {
      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
    }
    public static SpeedMessage2 ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
    }
    public static SpeedMessage2 ParseFrom(global::System.IO.Stream input) {
      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
    }
    public static SpeedMessage2 ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
    }
    public static SpeedMessage2 ParseDelimitedFrom(global::System.IO.Stream input) {
      return CreateBuilder().MergeDelimitedFrom(input).BuildParsed();
    }
    public static SpeedMessage2 ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
      return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed();
    }
    public static SpeedMessage2 ParseFrom(pb::ICodedInputStream input) {
      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
    }
    public static SpeedMessage2 ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
    }
    private SpeedMessage2 MakeReadOnly() {
      group1_.MakeReadOnly();
      field128_.MakeReadOnly();
      field127_.MakeReadOnly();
      field130_.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(SpeedMessage2 prototype) {
      return new Builder(prototype);
    }
    
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    public sealed partial class Builder : pb::GeneratedBuilder<SpeedMessage2, Builder> {
      protected override Builder ThisBuilder {
        get { return this; }
      }
      public Builder() {
        result = DefaultInstance;
        resultIsReadOnly = true;
      }
      internal Builder(SpeedMessage2 cloneFrom) {
        result = cloneFrom;
        resultIsReadOnly = true;
      }
      
      private bool resultIsReadOnly;
      private SpeedMessage2 result;
      
      private SpeedMessage2 PrepareBuilder() {
        if (resultIsReadOnly) {
          SpeedMessage2 original = result;
          result = new SpeedMessage2();
          resultIsReadOnly = false;
          MergeFrom(original);
        }
        return result;
      }
      
      public override bool IsInitialized {
        get { return result.IsInitialized; }
      }
      
      protected override SpeedMessage2 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.SpeedMessage2.Descriptor; }
      }
      
      public override SpeedMessage2 DefaultInstanceForType {
        get { return global::Google.ProtocolBuffers.TestProtos.SpeedMessage2.DefaultInstance; }
      }
      
      public override SpeedMessage2 BuildPartial() {
        if (resultIsReadOnly) {
          return result;
        }
        resultIsReadOnly = true;
        return result.MakeReadOnly();
      }
      
      public override Builder MergeFrom(pb::IMessage other) {
        if (other is SpeedMessage2) {
          return MergeFrom((SpeedMessage2) other);
        } else {
          base.MergeFrom(other);
          return this;
        }
      }
      
      public override Builder MergeFrom(SpeedMessage2 other) {
        if (other == global::Google.ProtocolBuffers.TestProtos.SpeedMessage2.DefaultInstance) return this;
        PrepareBuilder();
        if (other.HasField1) {
          Field1 = other.Field1;
        }
        if (other.HasField3) {
          Field3 = other.Field3;
        }
        if (other.HasField4) {
          Field4 = other.Field4;
        }
        if (other.HasField30) {
          Field30 = other.Field30;
        }
        if (other.HasField75) {
          Field75 = other.Field75;
        }
        if (other.HasField6) {
          Field6 = other.Field6;
        }
        if (other.HasField2) {
          Field2 = other.Field2;
        }
        if (other.HasField21) {
          Field21 = other.Field21;
        }
        if (other.HasField71) {
          Field71 = other.Field71;
        }
        if (other.HasField25) {
          Field25 = other.Field25;
        }
        if (other.HasField109) {
          Field109 = other.Field109;
        }
        if (other.HasField210) {
          Field210 = other.Field210;
        }
        if (other.HasField211) {
          Field211 = other.Field211;
        }
        if (other.HasField212) {
          Field212 = other.Field212;
        }
        if (other.HasField213) {
          Field213 = other.Field213;
        }
        if (other.HasField216) {
          Field216 = other.Field216;
        }
        if (other.HasField217) {
          Field217 = other.Field217;
        }
        if (other.HasField218) {
          Field218 = other.Field218;
        }
        if (other.HasField220) {
          Field220 = other.Field220;
        }
        if (other.HasField221) {
          Field221 = other.Field221;
        }
        if (other.HasField222) {
          Field222 = other.Field222;
        }
        if (other.HasField63) {
          Field63 = other.Field63;
        }
        if (other.group1_.Count != 0) {
          result.group1_.Add(other.group1_);
        }
        if (other.field128_.Count != 0) {
          result.field128_.Add(other.field128_);
        }
        if (other.HasField131) {
          Field131 = other.Field131;
        }
        if (other.field127_.Count != 0) {
          result.field127_.Add(other.field127_);
        }
        if (other.HasField129) {
          Field129 = other.Field129;
        }
        if (other.field130_.Count != 0) {
          result.field130_.Add(other.field130_);
        }
        if (other.HasField205) {
          Field205 = other.Field205;
        }
        if (other.HasField206) {
          Field206 = other.Field206;
        }
        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(_speedMessage2FieldNames, field_name, global::System.StringComparer.Ordinal);
            if(field_ordinal >= 0)
              tag = _speedMessage2FieldTags[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.hasField1 = input.ReadString(ref result.field1_);
              break;
            }
            case 18: {
              result.hasField2 = input.ReadBytes(ref result.field2_);
              break;
            }
            case 24: {
              result.hasField3 = input.ReadInt64(ref result.field3_);
              break;
            }
            case 32: {
              result.hasField4 = input.ReadInt64(ref result.field4_);
              break;
            }
            case 50: {
              result.hasField6 = input.ReadString(ref result.field6_);
              break;
            }
            case 83: {
              input.ReadGroupArray(tag, field_name, result.group1_, global::Google.ProtocolBuffers.TestProtos.SpeedMessage2.Types.Group1.DefaultInstance, extensionRegistry);
              break;
            }
            case 168: {
              result.hasField21 = input.ReadInt32(ref result.field21_);
              break;
            }
            case 205: {
              result.hasField25 = input.ReadFloat(ref result.field25_);
              break;
            }
            case 240: {
              result.hasField30 = input.ReadInt64(ref result.field30_);
              break;
            }
            case 504: {
              result.hasField63 = input.ReadInt32(ref result.field63_);
              break;
            }
            case 568: {
              result.hasField71 = input.ReadInt32(ref result.field71_);
              break;
            }
            case 600: {
              result.hasField75 = input.ReadBool(ref result.field75_);
              break;
            }
            case 872: {
              result.hasField109 = input.ReadInt32(ref result.field109_);
              break;
            }
            case 1018: {
              input.ReadStringArray(tag, field_name, result.field127_);
              break;
            }
            case 1026: {
              input.ReadStringArray(tag, field_name, result.field128_);
              break;
            }
            case 1032: {
              result.hasField129 = input.ReadInt32(ref result.field129_);
              break;
            }
            case 1042:
            case 1040: {
              input.ReadInt64Array(tag, field_name, result.field130_);
              break;
            }
            case 1048: {
              result.hasField131 = input.ReadInt64(ref result.field131_);
              break;
            }
            case 1640: {
              result.hasField205 = input.ReadBool(ref result.field205_);
              break;
            }
            case 1648: {
              result.hasField206 = input.ReadBool(ref result.field206_);
              break;
            }
            case 1680: {
              result.hasField210 = input.ReadInt32(ref result.field210_);
              break;
            }
            case 1688: {
              result.hasField211 = input.ReadInt32(ref result.field211_);
              break;
            }
            case 1696: {
              result.hasField212 = input.ReadInt32(ref result.field212_);
              break;
            }
            case 1704: {
              result.hasField213 = input.ReadInt32(ref result.field213_);
              break;
            }
            case 1728: {
              result.hasField216 = input.ReadInt32(ref result.field216_);
              break;
            }
            case 1736: {
              result.hasField217 = input.ReadInt32(ref result.field217_);
              break;
            }
            case 1744: {
              result.hasField218 = input.ReadInt32(ref result.field218_);
              break;
            }
            case 1760: {
              result.hasField220 = input.ReadInt32(ref result.field220_);
              break;
            }
            case 1768: {
              result.hasField221 = input.ReadInt32(ref result.field221_);
              break;
            }
            case 1781: {
              result.hasField222 = input.ReadFloat(ref result.field222_);
              break;
            }
          }
        }
        
        if (unknownFields != null) {
          this.UnknownFields = unknownFields.Build();
        }
        return this;
      }
      
      
      public bool HasField1 {
        get { return result.hasField1; }
      }
      public string Field1 {
        get { return result.Field1; }
        set { SetField1(value); }
      }
      public Builder SetField1(string value) {
        pb::ThrowHelper.ThrowIfNull(value, "value");
        PrepareBuilder();
        result.hasField1 = true;
        result.field1_ = value;
        return this;
      }
      public Builder ClearField1() {
        PrepareBuilder();
        result.hasField1 = false;
        result.field1_ = "";
        return this;
      }
      
      public bool HasField3 {
        get { return result.hasField3; }
      }
      public long Field3 {
        get { return result.Field3; }
        set { SetField3(value); }
      }
      public Builder SetField3(long value) {
        PrepareBuilder();
        result.hasField3 = true;
        result.field3_ = value;
        return this;
      }
      public Builder ClearField3() {
        PrepareBuilder();
        result.hasField3 = false;
        result.field3_ = 0L;
        return this;
      }
      
      public bool HasField4 {
        get { return result.hasField4; }
      }
      public long Field4 {
        get { return result.Field4; }
        set { SetField4(value); }
      }
      public Builder SetField4(long value) {
        PrepareBuilder();
        result.hasField4 = true;
        result.field4_ = value;
        return this;
      }
      public Builder ClearField4() {
        PrepareBuilder();
        result.hasField4 = false;
        result.field4_ = 0L;
        return this;
      }
      
      public bool HasField30 {
        get { return result.hasField30; }
      }
      public long Field30 {
        get { return result.Field30; }
        set { SetField30(value); }
      }
      public Builder SetField30(long value) {
        PrepareBuilder();
        result.hasField30 = true;
        result.field30_ = value;
        return this;
      }
      public Builder ClearField30() {
        PrepareBuilder();
        result.hasField30 = false;
        result.field30_ = 0L;
        return this;
      }
      
      public bool HasField75 {
        get { return result.hasField75; }
      }
      public bool Field75 {
        get { return result.Field75; }
        set { SetField75(value); }
      }
      public Builder SetField75(bool value) {
        PrepareBuilder();
        result.hasField75 = true;
        result.field75_ = value;
        return this;
      }
      public Builder ClearField75() {
        PrepareBuilder();
        result.hasField75 = false;
        result.field75_ = false;
        return this;
      }
      
      public bool HasField6 {
        get { return result.hasField6; }
      }
      public string Field6 {
        get { return result.Field6; }
        set { SetField6(value); }
      }
      public Builder SetField6(string value) {
        pb::ThrowHelper.ThrowIfNull(value, "value");
        PrepareBuilder();
        result.hasField6 = true;
        result.field6_ = value;
        return this;
      }
      public Builder ClearField6() {
        PrepareBuilder();
        result.hasField6 = false;
        result.field6_ = "";
        return this;
      }
      
      public bool HasField2 {
        get { return result.hasField2; }
      }
      public pb::ByteString Field2 {
        get { return result.Field2; }
        set { SetField2(value); }
      }
      public Builder SetField2(pb::ByteString value) {
        pb::ThrowHelper.ThrowIfNull(value, "value");
        PrepareBuilder();
        result.hasField2 = true;
        result.field2_ = value;
        return this;
      }
      public Builder ClearField2() {
        PrepareBuilder();
        result.hasField2 = false;
        result.field2_ = pb::ByteString.Empty;
        return this;
      }
      
      public bool HasField21 {
        get { return result.hasField21; }
      }
      public int Field21 {
        get { return result.Field21; }
        set { SetField21(value); }
      }
      public Builder SetField21(int value) {
        PrepareBuilder();
        result.hasField21 = true;
        result.field21_ = value;
        return this;
      }
      public Builder ClearField21() {
        PrepareBuilder();
        result.hasField21 = false;
        result.field21_ = 0;
        return this;
      }
      
      public bool HasField71 {
        get { return result.hasField71; }
      }
      public int Field71 {
        get { return result.Field71; }
        set { SetField71(value); }
      }
      public Builder SetField71(int value) {
        PrepareBuilder();
        result.hasField71 = true;
        result.field71_ = value;
        return this;
      }
      public Builder ClearField71() {
        PrepareBuilder();
        result.hasField71 = false;
        result.field71_ = 0;
        return this;
      }
      
      public bool HasField25 {
        get { return result.hasField25; }
      }
      public float Field25 {
        get { return result.Field25; }
        set { SetField25(value); }
      }
      public Builder SetField25(float value) {
        PrepareBuilder();
        result.hasField25 = true;
        result.field25_ = value;
        return this;
      }
      public Builder ClearField25() {
        PrepareBuilder();
        result.hasField25 = false;
        result.field25_ = 0F;
        return this;
      }
      
      public bool HasField109 {
        get { return result.hasField109; }
      }
      public int Field109 {
        get { return result.Field109; }
        set { SetField109(value); }
      }
      public Builder SetField109(int value) {
        PrepareBuilder();
        result.hasField109 = true;
        result.field109_ = value;
        return this;
      }
      public Builder ClearField109() {
        PrepareBuilder();
        result.hasField109 = false;
        result.field109_ = 0;
        return this;
      }
      
      public bool HasField210 {
        get { return result.hasField210; }
      }
      public int Field210 {
        get { return result.Field210; }
        set { SetField210(value); }
      }
      public Builder SetField210(int value) {
        PrepareBuilder();
        result.hasField210 = true;
        result.field210_ = value;
        return this;
      }
      public Builder ClearField210() {
        PrepareBuilder();
        result.hasField210 = false;
        result.field210_ = 0;
        return this;
      }
      
      public bool HasField211 {
        get { return result.hasField211; }
      }
      public int Field211 {
        get { return result.Field211; }
        set { SetField211(value); }
      }
      public Builder SetField211(int value) {
        PrepareBuilder();
        result.hasField211 = true;
        result.field211_ = value;
        return this;
      }
      public Builder ClearField211() {
        PrepareBuilder();
        result.hasField211 = false;
        result.field211_ = 0;
        return this;
      }
      
      public bool HasField212 {
        get { return result.hasField212; }
      }
      public int Field212 {
        get { return result.Field212; }
        set { SetField212(value); }
      }
      public Builder SetField212(int value) {
        PrepareBuilder();
        result.hasField212 = true;
        result.field212_ = value;
        return this;
      }
      public Builder ClearField212() {
        PrepareBuilder();
        result.hasField212 = false;
        result.field212_ = 0;
        return this;
      }
      
      public bool HasField213 {
        get { return result.hasField213; }
      }
      public int Field213 {
        get { return result.Field213; }
        set { SetField213(value); }
      }
      public Builder SetField213(int value) {
        PrepareBuilder();
        result.hasField213 = true;
        result.field213_ = value;
        return this;
      }
      public Builder ClearField213() {
        PrepareBuilder();
        result.hasField213 = false;
        result.field213_ = 0;
        return this;
      }
      
      public bool HasField216 {
        get { return result.hasField216; }
      }
      public int Field216 {
        get { return result.Field216; }
        set { SetField216(value); }
      }
      public Builder SetField216(int value) {
        PrepareBuilder();
        result.hasField216 = true;
        result.field216_ = value;
        return this;
      }
      public Builder ClearField216() {
        PrepareBuilder();
        result.hasField216 = false;
        result.field216_ = 0;
        return this;
      }
      
      public bool HasField217 {
        get { return result.hasField217; }
      }
      public int Field217 {
        get { return result.Field217; }
        set { SetField217(value); }
      }
      public Builder SetField217(int value) {
        PrepareBuilder();
        result.hasField217 = true;
        result.field217_ = value;
        return this;
      }
      public Builder ClearField217() {
        PrepareBuilder();
        result.hasField217 = false;
        result.field217_ = 0;
        return this;
      }
      
      public bool HasField218 {
        get { return result.hasField218; }
      }
      public int Field218 {
        get { return result.Field218; }
        set { SetField218(value); }
      }
      public Builder SetField218(int value) {
        PrepareBuilder();
        result.hasField218 = true;
        result.field218_ = value;
        return this;
      }
      public Builder ClearField218() {
        PrepareBuilder();
        result.hasField218 = false;
        result.field218_ = 0;
        return this;
      }
      
      public bool HasField220 {
        get { return result.hasField220; }
      }
      public int Field220 {
        get { return result.Field220; }
        set { SetField220(value); }
      }
      public Builder SetField220(int value) {
        PrepareBuilder();
        result.hasField220 = true;
        result.field220_ = value;
        return this;
      }
      public Builder ClearField220() {
        PrepareBuilder();
        result.hasField220 = false;
        result.field220_ = 0;
        return this;
      }
      
      public bool HasField221 {
        get { return result.hasField221; }
      }
      public int Field221 {
        get { return result.Field221; }
        set { SetField221(value); }
      }
      public Builder SetField221(int value) {
        PrepareBuilder();
        result.hasField221 = true;
        result.field221_ = value;
        return this;
      }
      public Builder ClearField221() {
        PrepareBuilder();
        result.hasField221 = false;
        result.field221_ = 0;
        return this;
      }
      
      public bool HasField222 {
        get { return result.hasField222; }
      }
      public float Field222 {
        get { return result.Field222; }
        set { SetField222(value); }
      }
      public Builder SetField222(float value) {
        PrepareBuilder();
        result.hasField222 = true;
        result.field222_ = value;
        return this;
      }
      public Builder ClearField222() {
        PrepareBuilder();
        result.hasField222 = false;
        result.field222_ = 0F;
        return this;
      }
      
      public bool HasField63 {
        get { return result.hasField63; }
      }
      public int Field63 {
        get { return result.Field63; }
        set { SetField63(value); }
      }
      public Builder SetField63(int value) {
        PrepareBuilder();
        result.hasField63 = true;
        result.field63_ = value;
        return this;
      }
      public Builder ClearField63() {
        PrepareBuilder();
        result.hasField63 = false;
        result.field63_ = 0;
        return this;
      }
      
      public pbc::IPopsicleList<global::Google.ProtocolBuffers.TestProtos.SpeedMessage2.Types.Group1> Group1List {
        get { return PrepareBuilder().group1_; }
      }
      public int Group1Count {
        get { return result.Group1Count; }
      }
      public global::Google.ProtocolBuffers.TestProtos.SpeedMessage2.Types.Group1 GetGroup1(int index) {
        return result.GetGroup1(index);
      }
      public Builder SetGroup1(int index, global::Google.ProtocolBuffers.TestProtos.SpeedMessage2.Types.Group1 value) {
        pb::ThrowHelper.ThrowIfNull(value, "value");
        PrepareBuilder();
        result.group1_[index] = value;
        return this;
      }
      public Builder SetGroup1(int index, global::Google.ProtocolBuffers.TestProtos.SpeedMessage2.Types.Group1.Builder builderForValue) {
        pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue");
        PrepareBuilder();
        result.group1_[index] = builderForValue.Build();
        return this;
      }
      public Builder AddGroup1(global::Google.ProtocolBuffers.TestProtos.SpeedMessage2.Types.Group1 value) {
        pb::ThrowHelper.ThrowIfNull(value, "value");
        PrepareBuilder();
        result.group1_.Add(value);
        return this;
      }
      public Builder AddGroup1(global::Google.ProtocolBuffers.TestProtos.SpeedMessage2.Types.Group1.Builder builderForValue) {
        pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue");
        PrepareBuilder();
        result.group1_.Add(builderForValue.Build());
        return this;
      }
      public Builder AddRangeGroup1(scg::IEnumerable<global::Google.ProtocolBuffers.TestProtos.SpeedMessage2.Types.Group1> values) {
        PrepareBuilder();
        result.group1_.Add(values);
        return this;
      }
      public Builder ClearGroup1() {
        PrepareBuilder();
        result.group1_.Clear();
        return this;
      }
      
      public pbc::IPopsicleList<string> Field128List {
        get { return PrepareBuilder().field128_; }
      }
      public int Field128Count {
        get { return result.Field128Count; }
      }
      public string GetField128(int index) {
        return result.GetField128(index);
      }
      public Builder SetField128(int index, string value) {
        pb::ThrowHelper.ThrowIfNull(value, "value");
        PrepareBuilder();
        result.field128_[index] = value;
        return this;
      }
      public Builder AddField128(string value) {
        pb::ThrowHelper.ThrowIfNull(value, "value");
        PrepareBuilder();
        result.field128_.Add(value);
        return this;
      }
      public Builder AddRangeField128(scg::IEnumerable<string> values) {
        PrepareBuilder();
        result.field128_.Add(values);
        return this;
      }
      public Builder ClearField128() {
        PrepareBuilder();
        result.field128_.Clear();
        return this;
      }
      
      public bool HasField131 {
        get { return result.hasField131; }
      }
      public long Field131 {
        get { return result.Field131; }
        set { SetField131(value); }
      }
      public Builder SetField131(long value) {
        PrepareBuilder();
        result.hasField131 = true;
        result.field131_ = value;
        return this;
      }
      public Builder ClearField131() {
        PrepareBuilder();
        result.hasField131 = false;
        result.field131_ = 0L;
        return this;
      }
      
      public pbc::IPopsicleList<string> Field127List {
        get { return PrepareBuilder().field127_; }
      }
      public int Field127Count {
        get { return result.Field127Count; }
      }
      public string GetField127(int index) {
        return result.GetField127(index);
      }
      public Builder SetField127(int index, string value) {
        pb::ThrowHelper.ThrowIfNull(value, "value");
        PrepareBuilder();
        result.field127_[index] = value;
        return this;
      }
      public Builder AddField127(string value) {
        pb::ThrowHelper.ThrowIfNull(value, "value");
        PrepareBuilder();
        result.field127_.Add(value);
        return this;
      }
      public Builder AddRangeField127(scg::IEnumerable<string> values) {
        PrepareBuilder();
        result.field127_.Add(values);
        return this;
      }
      public Builder ClearField127() {
        PrepareBuilder();
        result.field127_.Clear();
        return this;
      }
      
      public bool HasField129 {
        get { return result.hasField129; }
      }
      public int Field129 {
        get { return result.Field129; }
        set { SetField129(value); }
      }
      public Builder SetField129(int value) {
        PrepareBuilder();
        result.hasField129 = true;
        result.field129_ = value;
        return this;
      }
      public Builder ClearField129() {
        PrepareBuilder();
        result.hasField129 = false;
        result.field129_ = 0;
        return this;
      }
      
      public pbc::IPopsicleList<long> Field130List {
        get { return PrepareBuilder().field130_; }
      }
      public int Field130Count {
        get { return result.Field130Count; }
      }
      public long GetField130(int index) {
        return result.GetField130(index);
      }
      public Builder SetField130(int index, long value) {
        PrepareBuilder();
        result.field130_[index] = value;
        return this;
      }
      public Builder AddField130(long value) {
        PrepareBuilder();
        result.field130_.Add(value);
        return this;
      }
      public Builder AddRangeField130(scg::IEnumerable<long> values) {
        PrepareBuilder();
        result.field130_.Add(values);
        return this;
      }
      public Builder ClearField130() {
        PrepareBuilder();
        result.field130_.Clear();
        return this;
      }
      
      public bool HasField205 {
        get { return result.hasField205; }
      }
      public bool Field205 {
        get { return result.Field205; }
        set { SetField205(value); }
      }
      public Builder SetField205(bool value) {
        PrepareBuilder();
        result.hasField205 = true;
        result.field205_ = value;
        return this;
      }
      public Builder ClearField205() {
        PrepareBuilder();
        result.hasField205 = false;
        result.field205_ = false;
        return this;
      }
      
      public bool HasField206 {
        get { return result.hasField206; }
      }
      public bool Field206 {
        get { return result.Field206; }
        set { SetField206(value); }
      }
      public Builder SetField206(bool value) {
        PrepareBuilder();
        result.hasField206 = true;
        result.field206_ = value;
        return this;
      }
      public Builder ClearField206() {
        PrepareBuilder();
        result.hasField206 = false;
        result.field206_ = false;
        return this;
      }
    }
    static SpeedMessage2() {
      object.ReferenceEquals(global::Google.ProtocolBuffers.TestProtos.UnitTestGoogleSpeedProtoFile.Descriptor, null);
    }
  }
  
  [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
  public sealed partial class SpeedMessage2GroupedMessage : pb::GeneratedMessage<SpeedMessage2GroupedMessage, SpeedMessage2GroupedMessage.Builder> {
    private SpeedMessage2GroupedMessage() { }
    private static readonly SpeedMessage2GroupedMessage defaultInstance = new SpeedMessage2GroupedMessage().MakeReadOnly();
    private static readonly string[] _speedMessage2GroupedMessageFieldNames = new string[] { "field1", "field10", "field11", "field2", "field3", "field4", "field5", "field6", "field7", "field8", "field9" };
    private static readonly uint[] _speedMessage2GroupedMessageFieldTags = new uint[] { 13, 85, 88, 21, 29, 32, 40, 48, 56, 69, 72 };
    public static SpeedMessage2GroupedMessage DefaultInstance {
      get { return defaultInstance; }
    }
    
    public override SpeedMessage2GroupedMessage DefaultInstanceForType {
      get { return DefaultInstance; }
    }
    
    protected override SpeedMessage2GroupedMessage ThisMessage {
      get { return this; }
    }
    
    public static pbd::MessageDescriptor Descriptor {
      get { return global::Google.ProtocolBuffers.TestProtos.UnitTestGoogleSpeedProtoFile.internal__static_unittest_google_speed_SpeedMessage2GroupedMessage__Descriptor; }
    }
    
    protected override pb::FieldAccess.FieldAccessorTable<SpeedMessage2GroupedMessage, SpeedMessage2GroupedMessage.Builder> InternalFieldAccessors {
      get { return global::Google.ProtocolBuffers.TestProtos.UnitTestGoogleSpeedProtoFile.internal__static_unittest_google_speed_SpeedMessage2GroupedMessage__FieldAccessorTable; }
    }
    
    public const int Field1FieldNumber = 1;
    private bool hasField1;
    private float field1_;
    public bool HasField1 {
      get { return hasField1; }
    }
    public float Field1 {
      get { return field1_; }
    }
    
    public const int Field2FieldNumber = 2;
    private bool hasField2;
    private float field2_;
    public bool HasField2 {
      get { return hasField2; }
    }
    public float Field2 {
      get { return field2_; }
    }
    
    public const int Field3FieldNumber = 3;
    private bool hasField3;
    private float field3_;
    public bool HasField3 {
      get { return hasField3; }
    }
    public float Field3 {
      get { return field3_; }
    }
    
    public const int Field4FieldNumber = 4;
    private bool hasField4;
    private bool field4_;
    public bool HasField4 {
      get { return hasField4; }
    }
    public bool Field4 {
      get { return field4_; }
    }
    
    public const int Field5FieldNumber = 5;
    private bool hasField5;
    private bool field5_;
    public bool HasField5 {
      get { return hasField5; }
    }
    public bool Field5 {
      get { return field5_; }
    }
    
    public const int Field6FieldNumber = 6;
    private bool hasField6;
    private bool field6_ = true;
    public bool HasField6 {
      get { return hasField6; }
    }
    public bool Field6 {
      get { return field6_; }
    }
    
    public const int Field7FieldNumber = 7;
    private bool hasField7;
    private bool field7_;
    public bool HasField7 {
      get { return hasField7; }
    }
    public bool Field7 {
      get { return field7_; }
    }
    
    public const int Field8FieldNumber = 8;
    private bool hasField8;
    private float field8_;
    public bool HasField8 {
      get { return hasField8; }
    }
    public float Field8 {
      get { return field8_; }
    }
    
    public const int Field9FieldNumber = 9;
    private bool hasField9;
    private bool field9_;
    public bool HasField9 {
      get { return hasField9; }
    }
    public bool Field9 {
      get { return field9_; }
    }
    
    public const int Field10FieldNumber = 10;
    private bool hasField10;
    private float field10_;
    public bool HasField10 {
      get { return hasField10; }
    }
    public float Field10 {
      get { return field10_; }
    }
    
    public const int Field11FieldNumber = 11;
    private bool hasField11;
    private long field11_;
    public bool HasField11 {
      get { return hasField11; }
    }
    public long Field11 {
      get { return field11_; }
    }
    
    public override bool IsInitialized {
      get {
        return true;
      }
    }
    
    public override void WriteTo(pb::ICodedOutputStream output) {
      int size = SerializedSize;
      string[] field_names = _speedMessage2GroupedMessageFieldNames;
      if (hasField1) {
        output.WriteFloat(1, field_names[0], Field1);
      }
      if (hasField2) {
        output.WriteFloat(2, field_names[3], Field2);
      }
      if (hasField3) {
        output.WriteFloat(3, field_names[4], Field3);
      }
      if (hasField4) {
        output.WriteBool(4, field_names[5], Field4);
      }
      if (hasField5) {
        output.WriteBool(5, field_names[6], Field5);
      }
      if (hasField6) {
        output.WriteBool(6, field_names[7], Field6);
      }
      if (hasField7) {
        output.WriteBool(7, field_names[8], Field7);
      }
      if (hasField8) {
        output.WriteFloat(8, field_names[9], Field8);
      }
      if (hasField9) {
        output.WriteBool(9, field_names[10], Field9);
      }
      if (hasField10) {
        output.WriteFloat(10, field_names[1], Field10);
      }
      if (hasField11) {
        output.WriteInt64(11, field_names[2], Field11);
      }
      UnknownFields.WriteTo(output);
    }
    
    private int memoizedSerializedSize = -1;
    public override int SerializedSize {
      get {
        int size = memoizedSerializedSize;
        if (size != -1) return size;
        
        size = 0;
        if (hasField1) {
          size += pb::CodedOutputStream.ComputeFloatSize(1, Field1);
        }
        if (hasField2) {
          size += pb::CodedOutputStream.ComputeFloatSize(2, Field2);
        }
        if (hasField3) {
          size += pb::CodedOutputStream.ComputeFloatSize(3, Field3);
        }
        if (hasField4) {
          size += pb::CodedOutputStream.ComputeBoolSize(4, Field4);
        }
        if (hasField5) {
          size += pb::CodedOutputStream.ComputeBoolSize(5, Field5);
        }
        if (hasField6) {
          size += pb::CodedOutputStream.ComputeBoolSize(6, Field6);
        }
        if (hasField7) {
          size += pb::CodedOutputStream.ComputeBoolSize(7, Field7);
        }
        if (hasField8) {
          size += pb::CodedOutputStream.ComputeFloatSize(8, Field8);
        }
        if (hasField9) {
          size += pb::CodedOutputStream.ComputeBoolSize(9, Field9);
        }
        if (hasField10) {
          size += pb::CodedOutputStream.ComputeFloatSize(10, Field10);
        }
        if (hasField11) {
          size += pb::CodedOutputStream.ComputeInt64Size(11, Field11);
        }
        size += UnknownFields.SerializedSize;
        memoizedSerializedSize = size;
        return size;
      }
    }
    
    public static SpeedMessage2GroupedMessage ParseFrom(pb::ByteString data) {
      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
    }
    public static SpeedMessage2GroupedMessage ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
    }
    public static SpeedMessage2GroupedMessage ParseFrom(byte[] data) {
      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
    }
    public static SpeedMessage2GroupedMessage ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
    }
    public static SpeedMessage2GroupedMessage ParseFrom(global::System.IO.Stream input) {
      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
    }
    public static SpeedMessage2GroupedMessage ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
    }
    public static SpeedMessage2GroupedMessage ParseDelimitedFrom(global::System.IO.Stream input) {
      return CreateBuilder().MergeDelimitedFrom(input).BuildParsed();
    }
    public static SpeedMessage2GroupedMessage ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry) {
      return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed();
    }
    public static SpeedMessage2GroupedMessage ParseFrom(pb::ICodedInputStream input) {
      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
    }
    public static SpeedMessage2GroupedMessage ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
    }
    private SpeedMessage2GroupedMessage 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(SpeedMessage2GroupedMessage prototype) {
      return new Builder(prototype);
    }
    
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    public sealed partial class Builder : pb::GeneratedBuilder<SpeedMessage2GroupedMessage, Builder> {
      protected override Builder ThisBuilder {
        get { return this; }
      }
      public Builder() {
        result = DefaultInstance;
        resultIsReadOnly = true;
      }
      internal Builder(SpeedMessage2GroupedMessage cloneFrom) {
        result = cloneFrom;
        resultIsReadOnly = true;
      }
      
      private bool resultIsReadOnly;
      private SpeedMessage2GroupedMessage result;
      
      private SpeedMessage2GroupedMessage PrepareBuilder() {
        if (resultIsReadOnly) {
          SpeedMessage2GroupedMessage original = result;
          result = new SpeedMessage2GroupedMessage();
          resultIsReadOnly = false;
          MergeFrom(original);
        }
        return result;
      }
      
      public override bool IsInitialized {
        get { return result.IsInitialized; }
      }
      
      protected override SpeedMessage2GroupedMessage 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.SpeedMessage2GroupedMessage.Descriptor; }
      }
      
      public override SpeedMessage2GroupedMessage DefaultInstanceForType {
        get { return global::Google.ProtocolBuffers.TestProtos.SpeedMessage2GroupedMessage.DefaultInstance; }
      }
      
      public override SpeedMessage2GroupedMessage BuildPartial() {
        if (resultIsReadOnly) {
          return result;
        }
        resultIsReadOnly = true;
        return result.MakeReadOnly();
      }
      
      public override Builder MergeFrom(pb::IMessage other) {
        if (other is SpeedMessage2GroupedMessage) {
          return MergeFrom((SpeedMessage2GroupedMessage) other);
        } else {
          base.MergeFrom(other);
          return this;
        }
      }
      
      public override Builder MergeFrom(SpeedMessage2GroupedMessage other) {
        if (other == global::Google.ProtocolBuffers.TestProtos.SpeedMessage2GroupedMessage.DefaultInstance) return this;
        PrepareBuilder();
        if (other.HasField1) {
          Field1 = other.Field1;
        }
        if (other.HasField2) {
          Field2 = other.Field2;
        }
        if (other.HasField3) {
          Field3 = other.Field3;
        }
        if (other.HasField4) {
          Field4 = other.Field4;
        }
        if (other.HasField5) {
          Field5 = other.Field5;
        }
        if (other.HasField6) {
          Field6 = other.Field6;
        }
        if (other.HasField7) {
          Field7 = other.Field7;
        }
        if (other.HasField8) {
          Field8 = other.Field8;
        }
        if (other.HasField9) {
          Field9 = other.Field9;
        }
        if (other.HasField10) {
          Field10 = other.Field10;
        }
        if (other.HasField11) {
          Field11 = other.Field11;
        }
        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(_speedMessage2GroupedMessageFieldNames, field_name, global::System.StringComparer.Ordinal);
            if(field_ordinal >= 0)
              tag = _speedMessage2GroupedMessageFieldTags[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 13: {
              result.hasField1 = input.ReadFloat(ref result.field1_);
              break;
            }
            case 21: {
              result.hasField2 = input.ReadFloat(ref result.field2_);
              break;
            }
            case 29: {
              result.hasField3 = input.ReadFloat(ref result.field3_);
              break;
            }
            case 32: {
              result.hasField4 = input.ReadBool(ref result.field4_);
              break;
            }
            case 40: {
              result.hasField5 = input.ReadBool(ref result.field5_);
              break;
            }
            case 48: {
              result.hasField6 = input.ReadBool(ref result.field6_);
              break;
            }
            case 56: {
              result.hasField7 = input.ReadBool(ref result.field7_);
              break;
            }
            case 69: {
              result.hasField8 = input.ReadFloat(ref result.field8_);
              break;
            }
            case 72: {
              result.hasField9 = input.ReadBool(ref result.field9_);
              break;
            }
            case 85: {
              result.hasField10 = input.ReadFloat(ref result.field10_);
              break;
            }
            case 88: {
              result.hasField11 = input.ReadInt64(ref result.field11_);
              break;
            }
          }
        }
        
        if (unknownFields != null) {
          this.UnknownFields = unknownFields.Build();
        }
        return this;
      }
      
      
      public bool HasField1 {
        get { return result.hasField1; }
      }
      public float Field1 {
        get { return result.Field1; }
        set { SetField1(value); }
      }
      public Builder SetField1(float value) {
        PrepareBuilder();
        result.hasField1 = true;
        result.field1_ = value;
        return this;
      }
      public Builder ClearField1() {
        PrepareBuilder();
        result.hasField1 = false;
        result.field1_ = 0F;
        return this;
      }
      
      public bool HasField2 {
        get { return result.hasField2; }
      }
      public float Field2 {
        get { return result.Field2; }
        set { SetField2(value); }
      }
      public Builder SetField2(float value) {
        PrepareBuilder();
        result.hasField2 = true;
        result.field2_ = value;
        return this;
      }
      public Builder ClearField2() {
        PrepareBuilder();
        result.hasField2 = false;
        result.field2_ = 0F;
        return this;
      }
      
      public bool HasField3 {
        get { return result.hasField3; }
      }
      public float Field3 {
        get { return result.Field3; }
        set { SetField3(value); }
      }
      public Builder SetField3(float value) {
        PrepareBuilder();
        result.hasField3 = true;
        result.field3_ = value;
        return this;
      }
      public Builder ClearField3() {
        PrepareBuilder();
        result.hasField3 = false;
        result.field3_ = 0F;
        return this;
      }
      
      public bool HasField4 {
        get { return result.hasField4; }
      }
      public bool Field4 {
        get { return result.Field4; }
        set { SetField4(value); }
      }
      public Builder SetField4(bool value) {
        PrepareBuilder();
        result.hasField4 = true;
        result.field4_ = value;
        return this;
      }
      public Builder ClearField4() {
        PrepareBuilder();
        result.hasField4 = false;
        result.field4_ = false;
        return this;
      }
      
      public bool HasField5 {
        get { return result.hasField5; }
      }
      public bool Field5 {
        get { return result.Field5; }
        set { SetField5(value); }
      }
      public Builder SetField5(bool value) {
        PrepareBuilder();
        result.hasField5 = true;
        result.field5_ = value;
        return this;
      }
      public Builder ClearField5() {
        PrepareBuilder();
        result.hasField5 = false;
        result.field5_ = false;
        return this;
      }
      
      public bool HasField6 {
        get { return result.hasField6; }
      }
      public bool Field6 {
        get { return result.Field6; }
        set { SetField6(value); }
      }
      public Builder SetField6(bool value) {
        PrepareBuilder();
        result.hasField6 = true;
        result.field6_ = value;
        return this;
      }
      public Builder ClearField6() {
        PrepareBuilder();
        result.hasField6 = false;
        result.field6_ = true;
        return this;
      }
      
      public bool HasField7 {
        get { return result.hasField7; }
      }
      public bool Field7 {
        get { return result.Field7; }
        set { SetField7(value); }
      }
      public Builder SetField7(bool value) {
        PrepareBuilder();
        result.hasField7 = true;
        result.field7_ = value;
        return this;
      }
      public Builder ClearField7() {
        PrepareBuilder();
        result.hasField7 = false;
        result.field7_ = false;
        return this;
      }
      
      public bool HasField8 {
        get { return result.hasField8; }
      }
      public float Field8 {
        get { return result.Field8; }
        set { SetField8(value); }
      }
      public Builder SetField8(float value) {
        PrepareBuilder();
        result.hasField8 = true;
        result.field8_ = value;
        return this;
      }
      public Builder ClearField8() {
        PrepareBuilder();
        result.hasField8 = false;
        result.field8_ = 0F;
        return this;
      }
      
      public bool HasField9 {
        get { return result.hasField9; }
      }
      public bool Field9 {
        get { return result.Field9; }
        set { SetField9(value); }
      }
      public Builder SetField9(bool value) {
        PrepareBuilder();
        result.hasField9 = true;
        result.field9_ = value;
        return this;
      }
      public Builder ClearField9() {
        PrepareBuilder();
        result.hasField9 = false;
        result.field9_ = false;
        return this;
      }
      
      public bool HasField10 {
        get { return result.hasField10; }
      }
      public float Field10 {
        get { return result.Field10; }
        set { SetField10(value); }
      }
      public Builder SetField10(float value) {
        PrepareBuilder();
        result.hasField10 = true;
        result.field10_ = value;
        return this;
      }
      public Builder ClearField10() {
        PrepareBuilder();
        result.hasField10 = false;
        result.field10_ = 0F;
        return this;
      }
      
      public bool HasField11 {
        get { return result.hasField11; }
      }
      public long Field11 {
        get { return result.Field11; }
        set { SetField11(value); }
      }
      public Builder SetField11(long value) {
        PrepareBuilder();
        result.hasField11 = true;
        result.field11_ = value;
        return this;
      }
      public Builder ClearField11() {
        PrepareBuilder();
        result.hasField11 = false;
        result.field11_ = 0L;
        return this;
      }
    }
    static SpeedMessage2GroupedMessage() {
      object.ReferenceEquals(global::Google.ProtocolBuffers.TestProtos.UnitTestGoogleSpeedProtoFile.Descriptor, null);
    }
  }
  
  #endregion
  
}

#endregion Designer generated code
