Protocol Buffer runtime library and 'protoc' plugin

tests/lib/protobuf/unittest.pb.dart

+///
+//  Generated code. Do not modify.
+///
+class Protobuf_Unittest_ForeignEnum extends ProtobufEnum implements Hashable {
+  static Protobuf_Unittest_ForeignEnum get FOREIGN_FOO() => values[0];
+  static Protobuf_Unittest_ForeignEnum get FOREIGN_BAR() => values[1];
+  static Protobuf_Unittest_ForeignEnum get FOREIGN_BAZ() => values[2];
+  static List<Protobuf_Unittest_ForeignEnum> _byIndex;
+  static Map<int, Protobuf_Unittest_ForeignEnum> _byValue;
+
+  static void _init() {
+    _byIndex = const [
+      const Protobuf_Unittest_ForeignEnum._(0, 4, 'FOREIGN_FOO'),
+      const Protobuf_Unittest_ForeignEnum._(1, 5, 'FOREIGN_BAR'),
+      const Protobuf_Unittest_ForeignEnum._(2, 6, 'FOREIGN_BAZ'),
+    ];
+    _byValue = ProtobufEnum.initByValue(_byIndex);
+  }
+
+  static List<Protobuf_Unittest_ForeignEnum> get values() {
+    if (null == _byIndex) _init();
+    return _byIndex;
+  }
+
+  static Protobuf_Unittest_ForeignEnum valueOf(int value) {
+    if (null == _byValue) _init();
+    return _byValue[value];
+  }
+
+  bool operator ==(Object o) {
+    if (o is Protobuf_Unittest_ForeignEnum) {
+      Protobuf_Unittest_ForeignEnum p = o;
+      return value == p.value;
+    } else {
+      return false;
+    }
+  }
+
+  const Protobuf_Unittest_ForeignEnum._(int i, int v, String n) : super(i, v, n);
+}
+
+class Protobuf_Unittest_TestEnumWithDupValue extends ProtobufEnum implements Hashable {
+  static Protobuf_Unittest_TestEnumWithDupValue get FOO1() => values[0];
+  static Protobuf_Unittest_TestEnumWithDupValue get BAR1() => values[1];
+  static Protobuf_Unittest_TestEnumWithDupValue get BAZ() => values[2];
+  static List<Protobuf_Unittest_TestEnumWithDupValue> _byIndex;
+  static Map<int, Protobuf_Unittest_TestEnumWithDupValue> _byValue;
+
+  static void _init() {
+    _byIndex = const [
+      const Protobuf_Unittest_TestEnumWithDupValue._(0, 1, 'FOO1'),
+      const Protobuf_Unittest_TestEnumWithDupValue._(1, 2, 'BAR1'),
+      const Protobuf_Unittest_TestEnumWithDupValue._(2, 3, 'BAZ'),
+    ];
+    _byValue = ProtobufEnum.initByValue(_byIndex);
+  }
+
+  static List<Protobuf_Unittest_TestEnumWithDupValue> get values() {
+    if (null == _byIndex) _init();
+    return _byIndex;
+  }
+
+  static Protobuf_Unittest_TestEnumWithDupValue valueOf(int value) {
+    if (null == _byValue) _init();
+    return _byValue[value];
+  }
+
+  static final Protobuf_Unittest_TestEnumWithDupValue FOO2 = FOO1;
+  static final Protobuf_Unittest_TestEnumWithDupValue BAR2 = BAR1;
+
+  bool operator ==(Object o) {
+    if (o is Protobuf_Unittest_TestEnumWithDupValue) {
+      Protobuf_Unittest_TestEnumWithDupValue p = o;
+      return value == p.value;
+    } else {
+      return false;
+    }
+  }
+
+  const Protobuf_Unittest_TestEnumWithDupValue._(int i, int v, String n) : super(i, v, n);
+}
+
+class Protobuf_Unittest_TestSparseEnum extends ProtobufEnum implements Hashable {
+  static Protobuf_Unittest_TestSparseEnum get SPARSE_A() => values[0];
+  static Protobuf_Unittest_TestSparseEnum get SPARSE_B() => values[1];
+  static Protobuf_Unittest_TestSparseEnum get SPARSE_C() => values[2];
+  static Protobuf_Unittest_TestSparseEnum get SPARSE_D() => values[3];
+  static Protobuf_Unittest_TestSparseEnum get SPARSE_E() => values[4];
+  static Protobuf_Unittest_TestSparseEnum get SPARSE_F() => values[5];
+  static Protobuf_Unittest_TestSparseEnum get SPARSE_G() => values[6];
+  static List<Protobuf_Unittest_TestSparseEnum> _byIndex;
+  static Map<int, Protobuf_Unittest_TestSparseEnum> _byValue;
+
+  static void _init() {
+    _byIndex = const [
+      const Protobuf_Unittest_TestSparseEnum._(0, 123, 'SPARSE_A'),
+      const Protobuf_Unittest_TestSparseEnum._(1, 62374, 'SPARSE_B'),
+      const Protobuf_Unittest_TestSparseEnum._(2, 12589234, 'SPARSE_C'),
+      const Protobuf_Unittest_TestSparseEnum._(3, -15, 'SPARSE_D'),
+      const Protobuf_Unittest_TestSparseEnum._(4, -53452, 'SPARSE_E'),
+      const Protobuf_Unittest_TestSparseEnum._(5, 0, 'SPARSE_F'),
+      const Protobuf_Unittest_TestSparseEnum._(6, 2, 'SPARSE_G'),
+    ];
+    _byValue = ProtobufEnum.initByValue(_byIndex);
+  }
+
+  static List<Protobuf_Unittest_TestSparseEnum> get values() {
+    if (null == _byIndex) _init();
+    return _byIndex;
+  }
+
+  static Protobuf_Unittest_TestSparseEnum valueOf(int value) {
+    if (null == _byValue) _init();
+    return _byValue[value];
+  }
+
+  bool operator ==(Object o) {
+    if (o is Protobuf_Unittest_TestSparseEnum) {
+      Protobuf_Unittest_TestSparseEnum p = o;
+      return value == p.value;
+    } else {
+      return false;
+    }
+  }
+
+  const Protobuf_Unittest_TestSparseEnum._(int i, int v, String n) : super(i, v, n);
+}
+
+class Protobuf_Unittest_TestAllTypes_NestedEnum extends ProtobufEnum implements Hashable {
+  static Protobuf_Unittest_TestAllTypes_NestedEnum get FOO() => values[0];
+  static Protobuf_Unittest_TestAllTypes_NestedEnum get BAR() => values[1];
+  static Protobuf_Unittest_TestAllTypes_NestedEnum get BAZ() => values[2];
+  static List<Protobuf_Unittest_TestAllTypes_NestedEnum> _byIndex;
+  static Map<int, Protobuf_Unittest_TestAllTypes_NestedEnum> _byValue;
+
+  static void _init() {
+    _byIndex = const [
+      const Protobuf_Unittest_TestAllTypes_NestedEnum._(0, 1, 'FOO'),
+      const Protobuf_Unittest_TestAllTypes_NestedEnum._(1, 2, 'BAR'),
+      const Protobuf_Unittest_TestAllTypes_NestedEnum._(2, 3, 'BAZ'),
+    ];
+    _byValue = ProtobufEnum.initByValue(_byIndex);
+  }
+
+  static List<Protobuf_Unittest_TestAllTypes_NestedEnum> get values() {
+    if (null == _byIndex) _init();
+    return _byIndex;
+  }
+
+  static Protobuf_Unittest_TestAllTypes_NestedEnum valueOf(int value) {
+    if (null == _byValue) _init();
+    return _byValue[value];
+  }
+
+  bool operator ==(Object o) {
+    if (o is Protobuf_Unittest_TestAllTypes_NestedEnum) {
+      Protobuf_Unittest_TestAllTypes_NestedEnum p = o;
+      return value == p.value;
+    } else {
+      return false;
+    }
+  }
+
+  const Protobuf_Unittest_TestAllTypes_NestedEnum._(int i, int v, String n) : super(i, v, n);
+}
+
+class Protobuf_Unittest_TestAllTypes_NestedMessage extends GeneratedMessage {
+  static Protobuf_Unittest_TestAllTypes_NestedMessage _d;
+  static Protobuf_Unittest_TestAllTypes_NestedMessage_Builder newBuilder() => new Protobuf_Unittest_TestAllTypes_NestedMessage_Builder();
+  static Protobuf_Unittest_TestAllTypes_NestedMessage get defaultInstance() => null == _d ? (_d = newBuilder().buildPartial()) : _d;
+  static Protobuf_Unittest_TestAllTypes_NestedMessage parseFromBuffer(List<int> i, [ExtensionRegistry r]) => GeneratedMessage.parseBuffer(newBuilder(), i, r);
+  static Future<Protobuf_Unittest_TestAllTypes_NestedMessage> parseFromStream(InputStream i, [ExtensionRegistry r]) => GeneratedMessage.parseStream(newBuilder(), i, r);
+  static Protobuf_Unittest_TestAllTypes_NestedMessage parseFromJson(String i, [ExtensionRegistry r]) => GeneratedMessage.parseJson(newBuilder(), i, r);
+  Protobuf_Unittest_TestAllTypes_NestedMessage._fromBuilder(Protobuf_Unittest_TestAllTypes_NestedMessage_Builder b) : super(b);
+  Protobuf_Unittest_TestAllTypes_NestedMessage_Builder toBuilder() => newBuilder().mergeFromMessage(this);
+
+  // optional int32 bb = 1;
+  int get bb() => g_(1);
+  bool hasBb() => h_(1);
+}
+
+class Protobuf_Unittest_TestAllTypes_NestedMessage_Builder extends Builder {
+  static BuilderInfo _i;
+
+  void initialize_() {
+    if (null == _i) {
+      _i = new BuilderInfo(this, "Protobuf_Unittest_TestAllTypes_NestedMessage");
+      _i.a(1, 'bb', Builder.O3);
+      _i.hasRequiredFields = false;
+    }
+  }
+
+  Protobuf_Unittest_TestAllTypes_NestedMessage build() => super.build();
+  Protobuf_Unittest_TestAllTypes_NestedMessage buildPartial() => partial(new Protobuf_Unittest_TestAllTypes_NestedMessage._fromBuilder(this));
+  BuilderInfo get info_() => _i;
+
+  int get bb() => g_(1);
+  void set bb(int v) { s_(1, v); }
+  bool hasBb() => h_(1);
+  void clearBb() => c_(1);
+}
+
+class Protobuf_Unittest_TestAllTypes_OptionalGroup extends GeneratedMessage {
+  static Protobuf_Unittest_TestAllTypes_OptionalGroup _d;
+  static Protobuf_Unittest_TestAllTypes_OptionalGroup_Builder newBuilder() => new Protobuf_Unittest_TestAllTypes_OptionalGroup_Builder();
+  static Protobuf_Unittest_TestAllTypes_OptionalGroup get defaultInstance() => null == _d ? (_d = newBuilder().buildPartial()) : _d;
+  static Protobuf_Unittest_TestAllTypes_OptionalGroup parseFromBuffer(List<int> i, [ExtensionRegistry r]) => GeneratedMessage.parseBuffer(newBuilder(), i, r);
+  static Future<Protobuf_Unittest_TestAllTypes_OptionalGroup> parseFromStream(InputStream i, [ExtensionRegistry r]) => GeneratedMessage.parseStream(newBuilder(), i, r);
+  static Protobuf_Unittest_TestAllTypes_OptionalGroup parseFromJson(String i, [ExtensionRegistry r]) => GeneratedMessage.parseJson(newBuilder(), i, r);
+  Protobuf_Unittest_TestAllTypes_OptionalGroup._fromBuilder(Protobuf_Unittest_TestAllTypes_OptionalGroup_Builder b) : super(b);
+  Protobuf_Unittest_TestAllTypes_OptionalGroup_Builder toBuilder() => newBuilder().mergeFromMessage(this);
+
+  // optional int32 a = 17;
+  int get a() => g_(17);
+  bool hasA() => h_(17);
+}
+
+class Protobuf_Unittest_TestAllTypes_OptionalGroup_Builder extends Builder {
+  static BuilderInfo _i;
+
+  void initialize_() {
+    if (null == _i) {
+      _i = new BuilderInfo(this, "Protobuf_Unittest_TestAllTypes_OptionalGroup");
+      _i.a(17, 'a', Builder.O3);
+      _i.hasRequiredFields = false;
+    }
+  }
+
+  Protobuf_Unittest_TestAllTypes_OptionalGroup build() => super.build();
+  Protobuf_Unittest_TestAllTypes_OptionalGroup buildPartial() => partial(new Protobuf_Unittest_TestAllTypes_OptionalGroup._fromBuilder(this));
+  BuilderInfo get info_() => _i;
+
+  int get a() => g_(17);
+  void set a(int v) { s_(17, v); }
+  bool hasA() => h_(17);
+  void clearA() => c_(17);
+}
+
+class Protobuf_Unittest_TestAllTypes_RepeatedGroup extends GeneratedMessage {
+  static Protobuf_Unittest_TestAllTypes_RepeatedGroup _d;
+  static Protobuf_Unittest_TestAllTypes_RepeatedGroup_Builder newBuilder() => new Protobuf_Unittest_TestAllTypes_RepeatedGroup_Builder();
+  static Protobuf_Unittest_TestAllTypes_RepeatedGroup get defaultInstance() => null == _d ? (_d = newBuilder().buildPartial()) : _d;
+  static Protobuf_Unittest_TestAllTypes_RepeatedGroup parseFromBuffer(List<int> i, [ExtensionRegistry r]) => GeneratedMessage.parseBuffer(newBuilder(), i, r);
+  static Future<Protobuf_Unittest_TestAllTypes_RepeatedGroup> parseFromStream(InputStream i, [ExtensionRegistry r]) => GeneratedMessage.parseStream(newBuilder(), i, r);
+  static Protobuf_Unittest_TestAllTypes_RepeatedGroup parseFromJson(String i, [ExtensionRegistry r]) => GeneratedMessage.parseJson(newBuilder(), i, r);
+  Protobuf_Unittest_TestAllTypes_RepeatedGroup._fromBuilder(Protobuf_Unittest_TestAllTypes_RepeatedGroup_Builder b) : super(b);
+  Protobuf_Unittest_TestAllTypes_RepeatedGroup_Builder toBuilder() => newBuilder().mergeFromMessage(this);
+
+  // optional int32 a = 47;
+  int get a() => g_(47);
+  bool hasA() => h_(47);
+}
+
+class Protobuf_Unittest_TestAllTypes_RepeatedGroup_Builder extends Builder {
+  static BuilderInfo _i;
+
+  void initialize_() {
+    if (null == _i) {
+      _i = new BuilderInfo(this, "Protobuf_Unittest_TestAllTypes_RepeatedGroup");
+      _i.a(47, 'a', Builder.O3);
+      _i.hasRequiredFields = false;
+    }
+  }
+
+  Protobuf_Unittest_TestAllTypes_RepeatedGroup build() => super.build();
+  Protobuf_Unittest_TestAllTypes_RepeatedGroup buildPartial() => partial(new Protobuf_Unittest_TestAllTypes_RepeatedGroup._fromBuilder(this));
+  BuilderInfo get info_() => _i;
+
+  int get a() => g_(47);
+  void set a(int v) { s_(47, v); }
+  bool hasA() => h_(47);
+  void clearA() => c_(47);
+}
+
+class Protobuf_Unittest_TestAllTypes extends GeneratedMessage {
+  static Protobuf_Unittest_TestAllTypes _d;
+  static Protobuf_Unittest_TestAllTypes_Builder newBuilder() => new Protobuf_Unittest_TestAllTypes_Builder();
+  static Protobuf_Unittest_TestAllTypes get defaultInstance() => null == _d ? (_d = newBuilder().buildPartial()) : _d;
+  static Protobuf_Unittest_TestAllTypes parseFromBuffer(List<int> i, [ExtensionRegistry r]) => GeneratedMessage.parseBuffer(newBuilder(), i, r);
+  static Future<Protobuf_Unittest_TestAllTypes> parseFromStream(InputStream i, [ExtensionRegistry r]) => GeneratedMessage.parseStream(newBuilder(), i, r);
+  static Protobuf_Unittest_TestAllTypes parseFromJson(String i, [ExtensionRegistry r]) => GeneratedMessage.parseJson(newBuilder(), i, r);
+  Protobuf_Unittest_TestAllTypes._fromBuilder(Protobuf_Unittest_TestAllTypes_Builder b) : super(b);
+  Protobuf_Unittest_TestAllTypes_Builder toBuilder() => newBuilder().mergeFromMessage(this);
+
+  // optional int32 optional_int32 = 1;
+  int get optionalInt32() => g_(1);
+  bool hasOptionalInt32() => h_(1);
+
+  // optional int64 optional_int64 = 2;
+  int get optionalInt64() => g_(2);
+  bool hasOptionalInt64() => h_(2);
+
+  // optional uint32 optional_uint32 = 3;
+  int get optionalUint32() => g_(3);
+  bool hasOptionalUint32() => h_(3);
+
+  // optional uint64 optional_uint64 = 4;
+  int get optionalUint64() => g_(4);
+  bool hasOptionalUint64() => h_(4);
+
+  // optional sint32 optional_sint32 = 5;
+  int get optionalSint32() => g_(5);
+  bool hasOptionalSint32() => h_(5);
+
+  // optional sint64 optional_sint64 = 6;
+  int get optionalSint64() => g_(6);
+  bool hasOptionalSint64() => h_(6);
+
+  // optional fixed32 optional_fixed32 = 7;
+  int get optionalFixed32() => g_(7);
+  bool hasOptionalFixed32() => h_(7);
+
+  // optional fixed64 optional_fixed64 = 8;
+  int get optionalFixed64() => g_(8);
+  bool hasOptionalFixed64() => h_(8);
+
+  // optional sfixed32 optional_sfixed32 = 9;
+  int get optionalSfixed32() => g_(9);
+  bool hasOptionalSfixed32() => h_(9);
+
+  // optional sfixed64 optional_sfixed64 = 10;
+  int get optionalSfixed64() => g_(10);
+  bool hasOptionalSfixed64() => h_(10);
+
+  // optional float optional_float = 11;
+  double get optionalFloat() => g_(11);
+  bool hasOptionalFloat() => h_(11);
+
+  // optional double optional_double = 12;
+  double get optionalDouble() => g_(12);
+  bool hasOptionalDouble() => h_(12);
+
+  // optional bool optional_bool = 13;
+  bool get optionalBool() => g_(13);
+  bool hasOptionalBool() => h_(13);
+
+  // optional string optional_string = 14;
+  String get optionalString() => g_(14);
+  bool hasOptionalString() => h_(14);
+
+  // optional bytes optional_bytes = 15;
+  List<int> get optionalBytes() => g_(15);
+  bool hasOptionalBytes() => h_(15);
+
+  // optional protobuf_unittest.TestAllTypes.OptionalGroup optionalgroup = 16;
+  Protobuf_Unittest_TestAllTypes_OptionalGroup get optionalGroup() => g_(16);
+  bool hasOptionalGroup() => h_(16);
+
+  // optional protobuf_unittest.TestAllTypes.NestedMessage optional_nested_message = 18;
+  Protobuf_Unittest_TestAllTypes_NestedMessage get optionalNestedMessage() => g_(18);
+  bool hasOptionalNestedMessage() => h_(18);
+
+  // optional protobuf_unittest.ForeignMessage optional_foreign_message = 19;
+  Protobuf_Unittest_ForeignMessage get optionalForeignMessage() => g_(19);
+  bool hasOptionalForeignMessage() => h_(19);
+
+  // optional protobuf_unittest_import.ImportMessage optional_import_message = 20;
+  Protobuf_Unittest_Import_ImportMessage get optionalImportMessage() => g_(20);
+  bool hasOptionalImportMessage() => h_(20);
+
+  // optional enum optional_nested_enum = 21;
+  Protobuf_Unittest_TestAllTypes_NestedEnum get optionalNestedEnum() => g_(21);
+  bool hasOptionalNestedEnum() => h_(21);
+
+  // optional enum optional_foreign_enum = 22;
+  Protobuf_Unittest_ForeignEnum get optionalForeignEnum() => g_(22);
+  bool hasOptionalForeignEnum() => h_(22);
+
+  // optional enum optional_import_enum = 23;
+  Protobuf_Unittest_Import_ImportEnum get optionalImportEnum() => g_(23);
+  bool hasOptionalImportEnum() => h_(23);
+
+  // optional string optional_string_piece = 24;
+  String get optionalStringPiece() => g_(24);
+  bool hasOptionalStringPiece() => h_(24);
+
+  // optional string optional_cord = 25;
+  String get optionalCord() => g_(25);
+  bool hasOptionalCord() => h_(25);
+
+  // repeated int32 repeated_int32 = 31;
+  List<int> get repeatedInt32() => g_(31);
+
+  // repeated int64 repeated_int64 = 32;
+  List<int> get repeatedInt64() => g_(32);
+
+  // repeated uint32 repeated_uint32 = 33;
+  List<int> get repeatedUint32() => g_(33);
+
+  // repeated uint64 repeated_uint64 = 34;
+  List<int> get repeatedUint64() => g_(34);
+
+  // repeated sint32 repeated_sint32 = 35;
+  List<int> get repeatedSint32() => g_(35);
+
+  // repeated sint64 repeated_sint64 = 36;
+  List<int> get repeatedSint64() => g_(36);
+
+  // repeated fixed32 repeated_fixed32 = 37;
+  List<int> get repeatedFixed32() => g_(37);
+
+  // repeated fixed64 repeated_fixed64 = 38;
+  List<int> get repeatedFixed64() => g_(38);
+
+  // repeated sfixed32 repeated_sfixed32 = 39;
+  List<int> get repeatedSfixed32() => g_(39);
+
+  // repeated sfixed64 repeated_sfixed64 = 40;
+  List<int> get repeatedSfixed64() => g_(40);
+
+  // repeated float repeated_float = 41;
+  List<double> get repeatedFloat() => g_(41);
+
+  // repeated double repeated_double = 42;
+  List<double> get repeatedDouble() => g_(42);
+
+  // repeated bool repeated_bool = 43;
+  List<bool> get repeatedBool() => g_(43);
+
+  // repeated string repeated_string = 44;
+  List<String> get repeatedString() => g_(44);
+
+  // repeated bytes repeated_bytes = 45;
+  List<List<int>> get repeatedBytes() => g_(45);
+
+  // repeated protobuf_unittest.TestAllTypes.RepeatedGroup repeatedgroup = 46;
+  List<Protobuf_Unittest_TestAllTypes_RepeatedGroup> get repeatedGroup() => g_(46);
+
+  // repeated protobuf_unittest.TestAllTypes.NestedMessage repeated_nested_message = 48;
+  List<Protobuf_Unittest_TestAllTypes_NestedMessage> get repeatedNestedMessage() => g_(48);
+
+  // repeated protobuf_unittest.ForeignMessage repeated_foreign_message = 49;
+  List<Protobuf_Unittest_ForeignMessage> get repeatedForeignMessage() => g_(49);
+
+  // repeated protobuf_unittest_import.ImportMessage repeated_import_message = 50;
+  List<Protobuf_Unittest_Import_ImportMessage> get repeatedImportMessage() => g_(50);
+
+  // repeated enum repeated_nested_enum = 51;
+  List<Protobuf_Unittest_TestAllTypes_NestedEnum> get repeatedNestedEnum() => g_(51);
+
+  // repeated enum repeated_foreign_enum = 52;
+  List<Protobuf_Unittest_ForeignEnum> get repeatedForeignEnum() => g_(52);
+
+  // repeated enum repeated_import_enum = 53;
+  List<Protobuf_Unittest_Import_ImportEnum> get repeatedImportEnum() => g_(53);
+
+  // repeated string repeated_string_piece = 54;
+  List<String> get repeatedStringPiece() => g_(54);
+
+  // repeated string repeated_cord = 55;
+  List<String> get repeatedCord() => g_(55);
+
+  // optional int32 default_int32 = 61;
+  int get defaultInt32() => g_(61);
+  bool hasDefaultInt32() => h_(61);
+
+  // optional int64 default_int64 = 62;
+  int get defaultInt64() => g_(62);
+  bool hasDefaultInt64() => h_(62);
+
+  // optional uint32 default_uint32 = 63;
+  int get defaultUint32() => g_(63);
+  bool hasDefaultUint32() => h_(63);
+
+  // optional uint64 default_uint64 = 64;
+  int get defaultUint64() => g_(64);
+  bool hasDefaultUint64() => h_(64);
+
+  // optional sint32 default_sint32 = 65;
+  int get defaultSint32() => g_(65);
+  bool hasDefaultSint32() => h_(65);
+
+  // optional sint64 default_sint64 = 66;
+  int get defaultSint64() => g_(66);
+  bool hasDefaultSint64() => h_(66);
+
+  // optional fixed32 default_fixed32 = 67;
+  int get defaultFixed32() => g_(67);
+  bool hasDefaultFixed32() => h_(67);
+
+  // optional fixed64 default_fixed64 = 68;
+  int get defaultFixed64() => g_(68);
+  bool hasDefaultFixed64() => h_(68);
+
+  // optional sfixed32 default_sfixed32 = 69;
+  int get defaultSfixed32() => g_(69);
+  bool hasDefaultSfixed32() => h_(69);
+
+  // optional sfixed64 default_sfixed64 = 70;
+  int get defaultSfixed64() => g_(70);
+  bool hasDefaultSfixed64() => h_(70);
+
+  // optional float default_float = 71;
+  double get defaultFloat() => g_(71);
+  bool hasDefaultFloat() => h_(71);
+
+  // optional double default_double = 72;
+  double get defaultDouble() => g_(72);
+  bool hasDefaultDouble() => h_(72);
+
+  // optional bool default_bool = 73;
+  bool get defaultBool() => g_(73);
+  bool hasDefaultBool() => h_(73);
+
+  // optional string default_string = 74;
+  String get defaultString() => g_(74);
+  bool hasDefaultString() => h_(74);
+
+  // optional bytes default_bytes = 75;
+  List<int> get defaultBytes() => g_(75);
+  bool hasDefaultBytes() => h_(75);
+
+  // optional enum default_nested_enum = 81;
+  Protobuf_Unittest_TestAllTypes_NestedEnum get defaultNestedEnum() => g_(81);
+  bool hasDefaultNestedEnum() => h_(81);
+
+  // optional enum default_foreign_enum = 82;
+  Protobuf_Unittest_ForeignEnum get defaultForeignEnum() => g_(82);
+  bool hasDefaultForeignEnum() => h_(82);
+
+  // optional enum default_import_enum = 83;
+  Protobuf_Unittest_Import_ImportEnum get defaultImportEnum() => g_(83);
+  bool hasDefaultImportEnum() => h_(83);
+
+  // optional string default_string_piece = 84;
+  String get defaultStringPiece() => g_(84);
+  bool hasDefaultStringPiece() => h_(84);
+
+  // optional string default_cord = 85;
+  String get defaultCord() => g_(85);
+  bool hasDefaultCord() => h_(85);
+}
+
+class Protobuf_Unittest_TestAllTypes_Builder extends Builder {
+  static BuilderInfo _i;
+
+  void initialize_() {
+    if (null == _i) {
+      _i = new BuilderInfo(this, "Protobuf_Unittest_TestAllTypes");
+      _i.a(1, 'optionalInt32', Builder.O3);
+      _i.a(2, 'optionalInt64', Builder.O6);
+      _i.a(3, 'optionalUint32', Builder.OU3);
+      _i.a(4, 'optionalUint64', Builder.OU6);
+      _i.a(5, 'optionalSint32', Builder.OS3);
+      _i.a(6, 'optionalSint64', Builder.OS6);
+      _i.a(7, 'optionalFixed32', Builder.OF3);
+      _i.a(8, 'optionalFixed64', Builder.OF6);
+      _i.a(9, 'optionalSfixed32', Builder.OSF3);
+      _i.a(10, 'optionalSfixed64', Builder.OSF6);
+      _i.a(11, 'optionalFloat', Builder.OF);
+      _i.a(12, 'optionalDouble', Builder.OD);
+      _i.a(13, 'optionalBool', Builder.OB);
+      _i.a(14, 'optionalString', Builder.OS);
+      _i.a(15, 'optionalBytes', Builder.OY);
+      _i.a(16, 'optionalGroup', Builder.OG, () => Protobuf_Unittest_TestAllTypes_OptionalGroup.defaultInstance, () => new Protobuf_Unittest_TestAllTypes_OptionalGroup_Builder());
+      _i.a(18, 'optionalNestedMessage', Builder.OM, () => Protobuf_Unittest_TestAllTypes_NestedMessage.defaultInstance, () => new Protobuf_Unittest_TestAllTypes_NestedMessage_Builder());
+      _i.a(19, 'optionalForeignMessage', Builder.OM, () => Protobuf_Unittest_ForeignMessage.defaultInstance, () => new Protobuf_Unittest_ForeignMessage_Builder());
+      _i.a(20, 'optionalImportMessage', Builder.OM, () => Protobuf_Unittest_Import_ImportMessage.defaultInstance, () => new Protobuf_Unittest_Import_ImportMessage_Builder());
+      _i.e(21, 'optionalNestedEnum', Builder.OE, () => Protobuf_Unittest_TestAllTypes_NestedEnum.FOO, (var v) => Protobuf_Unittest_TestAllTypes_NestedEnum.valueOf(v));
+      _i.e(22, 'optionalForeignEnum', Builder.OE, () => Protobuf_Unittest_ForeignEnum.FOREIGN_FOO, (var v) => Protobuf_Unittest_ForeignEnum.valueOf(v));
+      _i.e(23, 'optionalImportEnum', Builder.OE, () => Protobuf_Unittest_Import_ImportEnum.IMPORT_FOO, (var v) => Protobuf_Unittest_Import_ImportEnum.valueOf(v));
+      _i.a(24, 'optionalStringPiece', Builder.OS);
+      _i.a(25, 'optionalCord', Builder.OS);
+      _i.p(31, 'repeatedInt32', Builder.P3);
+      _i.p(32, 'repeatedInt64', Builder.P6);
+      _i.p(33, 'repeatedUint32', Builder.PU3);
+      _i.p(34, 'repeatedUint64', Builder.PU6);
+      _i.p(35, 'repeatedSint32', Builder.PS3);
+      _i.p(36, 'repeatedSint64', Builder.PS6);
+      _i.p(37, 'repeatedFixed32', Builder.PF3);
+      _i.p(38, 'repeatedFixed64', Builder.PF6);
+      _i.p(39, 'repeatedSfixed32', Builder.PSF3);
+      _i.p(40, 'repeatedSfixed64', Builder.PSF6);
+      _i.p(41, 'repeatedFloat', Builder.PF);
+      _i.p(42, 'repeatedDouble', Builder.PD);
+      _i.p(43, 'repeatedBool', Builder.PB);
+      _i.p(44, 'repeatedString', Builder.PS);
+      _i.p(45, 'repeatedBytes', Builder.PY);
+      _i.a(46, 'repeatedGroup', Builder.PG, () => new PbList(this), () => new Protobuf_Unittest_TestAllTypes_RepeatedGroup_Builder());
+      _i.m(48, 'repeatedNestedMessage', () => new Protobuf_Unittest_TestAllTypes_NestedMessage_Builder(), () => new PbList<Protobuf_Unittest_TestAllTypes_NestedMessage>(this));
+      _i.m(49, 'repeatedForeignMessage', () => new Protobuf_Unittest_ForeignMessage_Builder(), () => new PbList<Protobuf_Unittest_ForeignMessage>(this));
+      _i.m(50, 'repeatedImportMessage', () => new Protobuf_Unittest_Import_ImportMessage_Builder(), () => new PbList<Protobuf_Unittest_Import_ImportMessage>(this));
+      _i.a(51, 'repeatedNestedEnum', Builder.PE, () => new PbList(this), null, (var v) => Protobuf_Unittest_TestAllTypes_NestedEnum.valueOf(v));
+      _i.a(52, 'repeatedForeignEnum', Builder.PE, () => new PbList(this), null, (var v) => Protobuf_Unittest_ForeignEnum.valueOf(v));
+      _i.a(53, 'repeatedImportEnum', Builder.PE, () => new PbList(this), null, (var v) => Protobuf_Unittest_Import_ImportEnum.valueOf(v));
+      _i.p(54, 'repeatedStringPiece', Builder.PS);
+      _i.p(55, 'repeatedCord', Builder.PS);
+      _i.a(61, 'defaultInt32', Builder.O3, () => 41);
+      _i.a(62, 'defaultInt64', Builder.O6, () => 42);
+      _i.a(63, 'defaultUint32', Builder.OU3, () => 43);
+      _i.a(64, 'defaultUint64', Builder.OU6, () => 44);
+      _i.a(65, 'defaultSint32', Builder.OS3, () => -45);
+      _i.a(66, 'defaultSint64', Builder.OS6, () => 46);
+      _i.a(67, 'defaultFixed32', Builder.OF3, () => 47);
+      _i.a(68, 'defaultFixed64', Builder.OF6, () => 48);
+      _i.a(69, 'defaultSfixed32', Builder.OSF3, () => 49);
+      _i.a(70, 'defaultSfixed64', Builder.OSF6, () => -50);
+      _i.a(71, 'defaultFloat', Builder.OF, () => 51.5);
+      _i.a(72, 'defaultDouble', Builder.OD, () => 52000.0);
+      _i.a(73, 'defaultBool', Builder.OB, () => true);
+      _i.a(74, 'defaultString', Builder.OS, () => 'hello');
+      _i.a(75, 'defaultBytes', Builder.OY, () => <int>[0x77,0x6f,0x72,0x6c,0x64]);
+      _i.e(81, 'defaultNestedEnum', Builder.OE, () => Protobuf_Unittest_TestAllTypes_NestedEnum.BAR, (var v) => Protobuf_Unittest_TestAllTypes_NestedEnum.valueOf(v));
+      _i.e(82, 'defaultForeignEnum', Builder.OE, () => Protobuf_Unittest_ForeignEnum.FOREIGN_BAR, (var v) => Protobuf_Unittest_ForeignEnum.valueOf(v));
+      _i.e(83, 'defaultImportEnum', Builder.OE, () => Protobuf_Unittest_Import_ImportEnum.IMPORT_BAR, (var v) => Protobuf_Unittest_Import_ImportEnum.valueOf(v));
+      _i.a(84, 'defaultStringPiece', Builder.OS, () => 'abc');
+      _i.a(85, 'defaultCord', Builder.OS, () => '123');
+      _i.hasRequiredFields = false;
+    }
+  }
+
+  Protobuf_Unittest_TestAllTypes build() => super.build();
+  Protobuf_Unittest_TestAllTypes buildPartial() => partial(new Protobuf_Unittest_TestAllTypes._fromBuilder(this));
+  BuilderInfo get info_() => _i;
+
+  int get optionalInt32() => g_(1);
+  void set optionalInt32(int v) { s_(1, v); }
+  bool hasOptionalInt32() => h_(1);
+  void clearOptionalInt32() => c_(1);
+
+  int get optionalInt64() => g_(2);
+  void set optionalInt64(int v) { s_(2, v); }
+  bool hasOptionalInt64() => h_(2);
+  void clearOptionalInt64() => c_(2);
+
+  int get optionalUint32() => g_(3);
+  void set optionalUint32(int v) { s_(3, v); }
+  bool hasOptionalUint32() => h_(3);
+  void clearOptionalUint32() => c_(3);
+
+  int get optionalUint64() => g_(4);
+  void set optionalUint64(int v) { s_(4, v); }
+  bool hasOptionalUint64() => h_(4);
+  void clearOptionalUint64() => c_(4);
+
+  int get optionalSint32() => g_(5);
+  void set optionalSint32(int v) { s_(5, v); }
+  bool hasOptionalSint32() => h_(5);
+  void clearOptionalSint32() => c_(5);
+
+  int get optionalSint64() => g_(6);
+  void set optionalSint64(int v) { s_(6, v); }
+  bool hasOptionalSint64() => h_(6);
+  void clearOptionalSint64() => c_(6);
+
+  int get optionalFixed32() => g_(7);
+  void set optionalFixed32(int v) { s_(7, v); }
+  bool hasOptionalFixed32() => h_(7);
+  void clearOptionalFixed32() => c_(7);
+
+  int get optionalFixed64() => g_(8);
+  void set optionalFixed64(int v) { s_(8, v); }
+  bool hasOptionalFixed64() => h_(8);
+  void clearOptionalFixed64() => c_(8);
+
+  int get optionalSfixed32() => g_(9);
+  void set optionalSfixed32(int v) { s_(9, v); }
+  bool hasOptionalSfixed32() => h_(9);
+  void clearOptionalSfixed32() => c_(9);
+
+  int get optionalSfixed64() => g_(10);
+  void set optionalSfixed64(int v) { s_(10, v); }
+  bool hasOptionalSfixed64() => h_(10);
+  void clearOptionalSfixed64() => c_(10);
+
+  double get optionalFloat() => g_(11);
+  void set optionalFloat(double v) { s_(11, v); }
+  bool hasOptionalFloat() => h_(11);
+  void clearOptionalFloat() => c_(11);
+
+  double get optionalDouble() => g_(12);
+  void set optionalDouble(double v) { s_(12, v); }
+  bool hasOptionalDouble() => h_(12);
+  void clearOptionalDouble() => c_(12);
+
+  bool get optionalBool() => g_(13);
+  void set optionalBool(bool v) { s_(13, v); }
+  bool hasOptionalBool() => h_(13);
+  void clearOptionalBool() => c_(13);
+
+  String get optionalString() => g_(14);
+  void set optionalString(String v) { s_(14, v); }
+  bool hasOptionalString() => h_(14);
+  void clearOptionalString() => c_(14);
+
+  List<int> get optionalBytes() => g_(15);
+  void set optionalBytes(List<int> v) { s_(15, v); }
+  bool hasOptionalBytes() => h_(15);
+  void clearOptionalBytes() => c_(15);
+
+  Protobuf_Unittest_TestAllTypes_OptionalGroup get optionalGroup() => g_(16);
+  void set optionalGroup(Protobuf_Unittest_TestAllTypes_OptionalGroup v) { s_(16, v); }
+  bool hasOptionalGroup() => h_(16);
+  void clearOptionalGroup() => c_(16);
+
+  Protobuf_Unittest_TestAllTypes_NestedMessage get optionalNestedMessage() => g_(18);
+  void set optionalNestedMessage(Protobuf_Unittest_TestAllTypes_NestedMessage v) { s_(18, v); }
+  bool hasOptionalNestedMessage() => h_(18);
+  void clearOptionalNestedMessage() => c_(18);
+
+  Protobuf_Unittest_ForeignMessage get optionalForeignMessage() => g_(19);
+  void set optionalForeignMessage(Protobuf_Unittest_ForeignMessage v) { s_(19, v); }
+  bool hasOptionalForeignMessage() => h_(19);
+  void clearOptionalForeignMessage() => c_(19);
+
+  Protobuf_Unittest_Import_ImportMessage get optionalImportMessage() => g_(20);
+  void set optionalImportMessage(Protobuf_Unittest_Import_ImportMessage v) { s_(20, v); }
+  bool hasOptionalImportMessage() => h_(20);
+  void clearOptionalImportMessage() => c_(20);
+
+  Protobuf_Unittest_TestAllTypes_NestedEnum get optionalNestedEnum() => g_(21);
+  void set optionalNestedEnum(Protobuf_Unittest_TestAllTypes_NestedEnum v) { s_(21, v); }
+  bool hasOptionalNestedEnum() => h_(21);
+  void clearOptionalNestedEnum() => c_(21);
+
+  Protobuf_Unittest_ForeignEnum get optionalForeignEnum() => g_(22);
+  void set optionalForeignEnum(Protobuf_Unittest_ForeignEnum v) { s_(22, v); }
+  bool hasOptionalForeignEnum() => h_(22);
+  void clearOptionalForeignEnum() => c_(22);
+
+  Protobuf_Unittest_Import_ImportEnum get optionalImportEnum() => g_(23);
+  void set optionalImportEnum(Protobuf_Unittest_Import_ImportEnum v) { s_(23, v); }
+  bool hasOptionalImportEnum() => h_(23);
+  void clearOptionalImportEnum() => c_(23);
+
+  String get optionalStringPiece() => g_(24);
+  void set optionalStringPiece(String v) { s_(24, v); }
+  bool hasOptionalStringPiece() => h_(24);
+  void clearOptionalStringPiece() => c_(24);
+
+  String get optionalCord() => g_(25);
+  void set optionalCord(String v) { s_(25, v); }
+  bool hasOptionalCord() => h_(25);
+  void clearOptionalCord() => c_(25);
+
+  List<int> get repeatedInt32() => g_(31);
+
+  List<int> get repeatedInt64() => g_(32);
+
+  List<int> get repeatedUint32() => g_(33);
+
+  List<int> get repeatedUint64() => g_(34);
+
+  List<int> get repeatedSint32() => g_(35);
+
+  List<int> get repeatedSint64() => g_(36);
+
+  List<int> get repeatedFixed32() => g_(37);
+
+  List<int> get repeatedFixed64() => g_(38);
+
+  List<int> get repeatedSfixed32() => g_(39);
+
+  List<int> get repeatedSfixed64() => g_(40);
+
+  List<double> get repeatedFloat() => g_(41);
+
+  List<double> get repeatedDouble() => g_(42);
+
+  List<bool> get repeatedBool() => g_(43);
+
+  List<String> get repeatedString() => g_(44);
+
+  List<List<int>> get repeatedBytes() => g_(45);
+
+  List<Protobuf_Unittest_TestAllTypes_RepeatedGroup> get repeatedGroup() => g_(46);
+
+  List<Protobuf_Unittest_TestAllTypes_NestedMessage> get repeatedNestedMessage() => g_(48);
+
+  List<Protobuf_Unittest_ForeignMessage> get repeatedForeignMessage() => g_(49);
+
+  List<Protobuf_Unittest_Import_ImportMessage> get repeatedImportMessage() => g_(50);
+
+  List<Protobuf_Unittest_TestAllTypes_NestedEnum> get repeatedNestedEnum() => g_(51);
+
+  List<Protobuf_Unittest_ForeignEnum> get repeatedForeignEnum() => g_(52);
+
+  List<Protobuf_Unittest_Import_ImportEnum> get repeatedImportEnum() => g_(53);
+
+  List<String> get repeatedStringPiece() => g_(54);
+
+  List<String> get repeatedCord() => g_(55);
+
+  int get defaultInt32() => g_(61);
+  void set defaultInt32(int v) { s_(61, v); }
+  bool hasDefaultInt32() => h_(61);
+  void clearDefaultInt32() => c_(61);
+
+  int get defaultInt64() => g_(62);
+  void set defaultInt64(int v) { s_(62, v); }
+  bool hasDefaultInt64() => h_(62);
+  void clearDefaultInt64() => c_(62);
+
+  int get defaultUint32() => g_(63);
+  void set defaultUint32(int v) { s_(63, v); }
+  bool hasDefaultUint32() => h_(63);
+  void clearDefaultUint32() => c_(63);
+
+  int get defaultUint64() => g_(64);
+  void set defaultUint64(int v) { s_(64, v); }
+  bool hasDefaultUint64() => h_(64);
+  void clearDefaultUint64() => c_(64);
+
+  int get defaultSint32() => g_(65);
+  void set defaultSint32(int v) { s_(65, v); }
+  bool hasDefaultSint32() => h_(65);
+  void clearDefaultSint32() => c_(65);
+
+  int get defaultSint64() => g_(66);
+  void set defaultSint64(int v) { s_(66, v); }
+  bool hasDefaultSint64() => h_(66);
+  void clearDefaultSint64() => c_(66);
+
+  int get defaultFixed32() => g_(67);
+  void set defaultFixed32(int v) { s_(67, v); }
+  bool hasDefaultFixed32() => h_(67);
+  void clearDefaultFixed32() => c_(67);
+
+  int get defaultFixed64() => g_(68);
+  void set defaultFixed64(int v) { s_(68, v); }
+  bool hasDefaultFixed64() => h_(68);
+  void clearDefaultFixed64() => c_(68);
+
+  int get defaultSfixed32() => g_(69);
+  void set defaultSfixed32(int v) { s_(69, v); }
+  bool hasDefaultSfixed32() => h_(69);
+  void clearDefaultSfixed32() => c_(69);
+
+  int get defaultSfixed64() => g_(70);
+  void set defaultSfixed64(int v) { s_(70, v); }
+  bool hasDefaultSfixed64() => h_(70);
+  void clearDefaultSfixed64() => c_(70);
+
+  double get defaultFloat() => g_(71);
+  void set defaultFloat(double v) { s_(71, v); }
+  bool hasDefaultFloat() => h_(71);
+  void clearDefaultFloat() => c_(71);
+
+  double get defaultDouble() => g_(72);
+  void set defaultDouble(double v) { s_(72, v); }
+  bool hasDefaultDouble() => h_(72);
+  void clearDefaultDouble() => c_(72);
+
+  bool get defaultBool() => g_(73);
+  void set defaultBool(bool v) { s_(73, v); }
+  bool hasDefaultBool() => h_(73);
+  void clearDefaultBool() => c_(73);
+
+  String get defaultString() => g_(74);
+  void set defaultString(String v) { s_(74, v); }
+  bool hasDefaultString() => h_(74);
+  void clearDefaultString() => c_(74);
+
+  List<int> get defaultBytes() => g_(75);
+  void set defaultBytes(List<int> v) { s_(75, v); }
+  bool hasDefaultBytes() => h_(75);
+  void clearDefaultBytes() => c_(75);
+
+  Protobuf_Unittest_TestAllTypes_NestedEnum get defaultNestedEnum() => g_(81);
+  void set defaultNestedEnum(Protobuf_Unittest_TestAllTypes_NestedEnum v) { s_(81, v); }
+  bool hasDefaultNestedEnum() => h_(81);
+  void clearDefaultNestedEnum() => c_(81);
+
+  Protobuf_Unittest_ForeignEnum get defaultForeignEnum() => g_(82);
+  void set defaultForeignEnum(Protobuf_Unittest_ForeignEnum v) { s_(82, v); }
+  bool hasDefaultForeignEnum() => h_(82);
+  void clearDefaultForeignEnum() => c_(82);
+
+  Protobuf_Unittest_Import_ImportEnum get defaultImportEnum() => g_(83);
+  void set defaultImportEnum(Protobuf_Unittest_Import_ImportEnum v) { s_(83, v); }
+  bool hasDefaultImportEnum() => h_(83);
+  void clearDefaultImportEnum() => c_(83);
+
+  String get defaultStringPiece() => g_(84);
+  void set defaultStringPiece(String v) { s_(84, v); }
+  bool hasDefaultStringPiece() => h_(84);
+  void clearDefaultStringPiece() => c_(84);
+
+  String get defaultCord() => g_(85);
+  void set defaultCord(String v) { s_(85, v); }
+  bool hasDefaultCord() => h_(85);
+  void clearDefaultCord() => c_(85);
+}
+
+class Protobuf_Unittest_TestDeprecatedFields extends GeneratedMessage {
+  static Protobuf_Unittest_TestDeprecatedFields _d;
+  static Protobuf_Unittest_TestDeprecatedFields_Builder newBuilder() => new Protobuf_Unittest_TestDeprecatedFields_Builder();
+  static Protobuf_Unittest_TestDeprecatedFields get defaultInstance() => null == _d ? (_d = newBuilder().buildPartial()) : _d;
+  static Protobuf_Unittest_TestDeprecatedFields parseFromBuffer(List<int> i, [ExtensionRegistry r]) => GeneratedMessage.parseBuffer(newBuilder(), i, r);
+  static Future<Protobuf_Unittest_TestDeprecatedFields> parseFromStream(InputStream i, [ExtensionRegistry r]) => GeneratedMessage.parseStream(newBuilder(), i, r);
+  static Protobuf_Unittest_TestDeprecatedFields parseFromJson(String i, [ExtensionRegistry r]) => GeneratedMessage.parseJson(newBuilder(), i, r);
+  Protobuf_Unittest_TestDeprecatedFields._fromBuilder(Protobuf_Unittest_TestDeprecatedFields_Builder b) : super(b);
+  Protobuf_Unittest_TestDeprecatedFields_Builder toBuilder() => newBuilder().mergeFromMessage(this);
+
+  // optional int32 deprecated_int32 = 1;
+  int get deprecatedInt32() => g_(1);
+  bool hasDeprecatedInt32() => h_(1);
+}
+
+class Protobuf_Unittest_TestDeprecatedFields_Builder extends Builder {
+  static BuilderInfo _i;
+
+  void initialize_() {
+    if (null == _i) {
+      _i = new BuilderInfo(this, "Protobuf_Unittest_TestDeprecatedFields");
+      _i.a(1, 'deprecatedInt32', Builder.O3);
+      _i.hasRequiredFields = false;
+    }
+  }
+
+  Protobuf_Unittest_TestDeprecatedFields build() => super.build();
+  Protobuf_Unittest_TestDeprecatedFields buildPartial() => partial(new Protobuf_Unittest_TestDeprecatedFields._fromBuilder(this));
+  BuilderInfo get info_() => _i;
+
+  int get deprecatedInt32() => g_(1);
+  void set deprecatedInt32(int v) { s_(1, v); }
+  bool hasDeprecatedInt32() => h_(1);
+  void clearDeprecatedInt32() => c_(1);
+}
+
+class Protobuf_Unittest_ForeignMessage extends GeneratedMessage {
+  static Protobuf_Unittest_ForeignMessage _d;
+  static Protobuf_Unittest_ForeignMessage_Builder newBuilder() => new Protobuf_Unittest_ForeignMessage_Builder();
+  static Protobuf_Unittest_ForeignMessage get defaultInstance() => null == _d ? (_d = newBuilder().buildPartial()) : _d;
+  static Protobuf_Unittest_ForeignMessage parseFromBuffer(List<int> i, [ExtensionRegistry r]) => GeneratedMessage.parseBuffer(newBuilder(), i, r);
+  static Future<Protobuf_Unittest_ForeignMessage> parseFromStream(InputStream i, [ExtensionRegistry r]) => GeneratedMessage.parseStream(newBuilder(), i, r);
+  static Protobuf_Unittest_ForeignMessage parseFromJson(String i, [ExtensionRegistry r]) => GeneratedMessage.parseJson(newBuilder(), i, r);
+  Protobuf_Unittest_ForeignMessage._fromBuilder(Protobuf_Unittest_ForeignMessage_Builder b) : super(b);
+  Protobuf_Unittest_ForeignMessage_Builder toBuilder() => newBuilder().mergeFromMessage(this);
+
+  // optional int32 c = 1;
+  int get c() => g_(1);
+  bool hasC() => h_(1);
+}
+
+class Protobuf_Unittest_ForeignMessage_Builder extends Builder {
+  static BuilderInfo _i;
+
+  void initialize_() {
+    if (null == _i) {
+      _i = new BuilderInfo(this, "Protobuf_Unittest_ForeignMessage");
+      _i.a(1, 'c', Builder.O3);
+      _i.hasRequiredFields = false;
+    }
+  }
+
+  Protobuf_Unittest_ForeignMessage build() => super.build();
+  Protobuf_Unittest_ForeignMessage buildPartial() => partial(new Protobuf_Unittest_ForeignMessage._fromBuilder(this));
+  BuilderInfo get info_() => _i;
+
+  int get c() => g_(1);
+  void set c(int v) { s_(1, v); }
+  bool hasC() => h_(1);
+  void clearC() => c_(1);
+}
+
+class Protobuf_Unittest_TestAllExtensions extends GeneratedMessage {
+  static Protobuf_Unittest_TestAllExtensions _d;
+  static Protobuf_Unittest_TestAllExtensions_Builder newBuilder() => new Protobuf_Unittest_TestAllExtensions_Builder();
+  static Protobuf_Unittest_TestAllExtensions get defaultInstance() => null == _d ? (_d = newBuilder().buildPartial()) : _d;
+  static Protobuf_Unittest_TestAllExtensions parseFromBuffer(List<int> i, [ExtensionRegistry r]) => GeneratedMessage.parseBuffer(newBuilder(), i, r);
+  static Future<Protobuf_Unittest_TestAllExtensions> parseFromStream(InputStream i, [ExtensionRegistry r]) => GeneratedMessage.parseStream(newBuilder(), i, r);
+  static Protobuf_Unittest_TestAllExtensions parseFromJson(String i, [ExtensionRegistry r]) => GeneratedMessage.parseJson(newBuilder(), i, r);
+  Protobuf_Unittest_TestAllExtensions._fromBuilder(Protobuf_Unittest_TestAllExtensions_Builder b) : super(b);
+  Protobuf_Unittest_TestAllExtensions_Builder toBuilder() => newBuilder().mergeFromMessage(this);
+}
+
+class Protobuf_Unittest_TestAllExtensions_Builder extends Builder {
+  static BuilderInfo _i;
+
+  void initialize_() {
+    if (null == _i) {
+      _i = new BuilderInfo(this, "Protobuf_Unittest_TestAllExtensions");
+      _i.hasExtensions = true;
+    }
+  }
+
+  Protobuf_Unittest_TestAllExtensions build() => super.build();
+  Protobuf_Unittest_TestAllExtensions buildPartial() => partial(new Protobuf_Unittest_TestAllExtensions._fromBuilder(this));
+  BuilderInfo get info_() => _i;
+}
+
+class Protobuf_Unittest_OptionalGroup_extension extends GeneratedMessage {
+  static Protobuf_Unittest_OptionalGroup_extension _d;
+  static Protobuf_Unittest_OptionalGroup_extension_Builder newBuilder() => new Protobuf_Unittest_OptionalGroup_extension_Builder();
+  static Protobuf_Unittest_OptionalGroup_extension get defaultInstance() => null == _d ? (_d = newBuilder().buildPartial()) : _d;
+  static Protobuf_Unittest_OptionalGroup_extension parseFromBuffer(List<int> i, [ExtensionRegistry r]) => GeneratedMessage.parseBuffer(newBuilder(), i, r);
+  static Future<Protobuf_Unittest_OptionalGroup_extension> parseFromStream(InputStream i, [ExtensionRegistry r]) => GeneratedMessage.parseStream(newBuilder(), i, r);
+  static Protobuf_Unittest_OptionalGroup_extension parseFromJson(String i, [ExtensionRegistry r]) => GeneratedMessage.parseJson(newBuilder(), i, r);
+  Protobuf_Unittest_OptionalGroup_extension._fromBuilder(Protobuf_Unittest_OptionalGroup_extension_Builder b) : super(b);
+  Protobuf_Unittest_OptionalGroup_extension_Builder toBuilder() => newBuilder().mergeFromMessage(this);
+
+  // optional int32 a = 17;
+  int get a() => g_(17);
+  bool hasA() => h_(17);
+}
+
+class Protobuf_Unittest_OptionalGroup_extension_Builder extends Builder {
+  static BuilderInfo _i;
+
+  void initialize_() {
+    if (null == _i) {
+      _i = new BuilderInfo(this, "Protobuf_Unittest_OptionalGroup_extension");
+      _i.a(17, 'a', Builder.O3);
+      _i.hasRequiredFields = false;
+    }
+  }
+
+  Protobuf_Unittest_OptionalGroup_extension build() => super.build();
+  Protobuf_Unittest_OptionalGroup_extension buildPartial() => partial(new Protobuf_Unittest_OptionalGroup_extension._fromBuilder(this));
+  BuilderInfo get info_() => _i;
+
+  int get a() => g_(17);
+  void set a(int v) { s_(17, v); }
+  bool hasA() => h_(17);
+  void clearA() => c_(17);
+}
+
+class Protobuf_Unittest_RepeatedGroup_extension extends GeneratedMessage {
+  static Protobuf_Unittest_RepeatedGroup_extension _d;
+  static Protobuf_Unittest_RepeatedGroup_extension_Builder newBuilder() => new Protobuf_Unittest_RepeatedGroup_extension_Builder();
+  static Protobuf_Unittest_RepeatedGroup_extension get defaultInstance() => null == _d ? (_d = newBuilder().buildPartial()) : _d;
+  static Protobuf_Unittest_RepeatedGroup_extension parseFromBuffer(List<int> i, [ExtensionRegistry r]) => GeneratedMessage.parseBuffer(newBuilder(), i, r);
+  static Future<Protobuf_Unittest_RepeatedGroup_extension> parseFromStream(InputStream i, [ExtensionRegistry r]) => GeneratedMessage.parseStream(newBuilder(), i, r);
+  static Protobuf_Unittest_RepeatedGroup_extension parseFromJson(String i, [ExtensionRegistry r]) => GeneratedMessage.parseJson(newBuilder(), i, r);
+  Protobuf_Unittest_RepeatedGroup_extension._fromBuilder(Protobuf_Unittest_RepeatedGroup_extension_Builder b) : super(b);
+  Protobuf_Unittest_RepeatedGroup_extension_Builder toBuilder() => newBuilder().mergeFromMessage(this);
+
+  // optional int32 a = 47;
+  int get a() => g_(47);
+  bool hasA() => h_(47);
+}
+
+class Protobuf_Unittest_RepeatedGroup_extension_Builder extends Builder {
+  static BuilderInfo _i;
+
+  void initialize_() {
+    if (null == _i) {
+      _i = new BuilderInfo(this, "Protobuf_Unittest_RepeatedGroup_extension");
+      _i.a(47, 'a', Builder.O3);
+      _i.hasRequiredFields = false;
+    }
+  }
+
+  Protobuf_Unittest_RepeatedGroup_extension build() => super.build();
+  Protobuf_Unittest_RepeatedGroup_extension buildPartial() => partial(new Protobuf_Unittest_RepeatedGroup_extension._fromBuilder(this));
+  BuilderInfo get info_() => _i;
+
+  int get a() => g_(47);
+  void set a(int v) { s_(47, v); }
+  bool hasA() => h_(47);
+  void clearA() => c_(47);
+}
+
+class Protobuf_Unittest_TestNestedExtension extends GeneratedMessage {
+  static Extension _test = null;
+  static Extension get test() {
+    if (null == _test ) {
+      _test = new Extension("Protobuf_Unittest_TestAllExtensions", "test", 1002, Builder.OS, () => 'test');
+    }
+    return _test;
+  }
+  static Protobuf_Unittest_TestNestedExtension _d;
+  static Protobuf_Unittest_TestNestedExtension_Builder newBuilder() => new Protobuf_Unittest_TestNestedExtension_Builder();
+  static Protobuf_Unittest_TestNestedExtension get defaultInstance() => null == _d ? (_d = newBuilder().buildPartial()) : _d;
+  static Protobuf_Unittest_TestNestedExtension parseFromBuffer(List<int> i, [ExtensionRegistry r]) => GeneratedMessage.parseBuffer(newBuilder(), i, r);
+  static Future<Protobuf_Unittest_TestNestedExtension> parseFromStream(InputStream i, [ExtensionRegistry r]) => GeneratedMessage.parseStream(newBuilder(), i, r);
+  static Protobuf_Unittest_TestNestedExtension parseFromJson(String i, [ExtensionRegistry r]) => GeneratedMessage.parseJson(newBuilder(), i, r);
+  Protobuf_Unittest_TestNestedExtension._fromBuilder(Protobuf_Unittest_TestNestedExtension_Builder b) : super(b);
+  Protobuf_Unittest_TestNestedExtension_Builder toBuilder() => newBuilder().mergeFromMessage(this);
+}
+
+class Protobuf_Unittest_TestNestedExtension_Builder extends Builder {
+  static BuilderInfo _i;
+
+  void initialize_() {
+    if (null == _i) {
+      _i = new BuilderInfo(this, "Protobuf_Unittest_TestNestedExtension");
+      _i.hasRequiredFields = false;
+    }
+  }
+
+  Protobuf_Unittest_TestNestedExtension build() => super.build();
+  Protobuf_Unittest_TestNestedExtension buildPartial() => partial(new Protobuf_Unittest_TestNestedExtension._fromBuilder(this));
+  BuilderInfo get info_() => _i;
+}
+
+class Protobuf_Unittest_TestRequired extends GeneratedMessage {
+  static Extension _single = null;
+  static Extension get single() {
+    if (null == _single ) {
+      _single = new Extension("Protobuf_Unittest_TestAllExtensions", "single", 1000, Builder.OM, () => Protobuf_Unittest_TestRequired.defaultInstance, () => new Protobuf_Unittest_TestRequired_Builder());
+    }
+    return _single;
+  }
+  static Extension _multi = null;
+  static Extension get multi() {
+    if (null == _multi ) {
+      _multi = new Extension("Protobuf_Unittest_TestAllExtensions", "multi", 1001, Builder.PM, () => new PbList<Protobuf_Unittest_TestRequired>(null), () => new Protobuf_Unittest_TestRequired_Builder());
+    }
+    return _multi;
+  }
+  static Protobuf_Unittest_TestRequired _d;
+  static Protobuf_Unittest_TestRequired_Builder newBuilder() => new Protobuf_Unittest_TestRequired_Builder();
+  static Protobuf_Unittest_TestRequired get defaultInstance() => null == _d ? (_d = newBuilder().buildPartial()) : _d;
+  static Protobuf_Unittest_TestRequired parseFromBuffer(List<int> i, [ExtensionRegistry r]) => GeneratedMessage.parseBuffer(newBuilder(), i, r);
+  static Future<Protobuf_Unittest_TestRequired> parseFromStream(InputStream i, [ExtensionRegistry r]) => GeneratedMessage.parseStream(newBuilder(), i, r);
+  static Protobuf_Unittest_TestRequired parseFromJson(String i, [ExtensionRegistry r]) => GeneratedMessage.parseJson(newBuilder(), i, r);
+  Protobuf_Unittest_TestRequired._fromBuilder(Protobuf_Unittest_TestRequired_Builder b) : super(b);
+  Protobuf_Unittest_TestRequired_Builder toBuilder() => newBuilder().mergeFromMessage(this);
+
+  // required int32 a = 1;
+  int get a() => g_(1);
+  bool hasA() => h_(1);
+
+  // optional int32 dummy2 = 2;
+  int get dummy2() => g_(2);
+  bool hasDummy2() => h_(2);
+
+  // required int32 b = 3;
+  int get b() => g_(3);
+  bool hasB() => h_(3);
+
+  // optional int32 dummy4 = 4;
+  int get dummy4() => g_(4);
+  bool hasDummy4() => h_(4);
+
+  // optional int32 dummy5 = 5;
+  int get dummy5() => g_(5);
+  bool hasDummy5() => h_(5);
+
+  // optional int32 dummy6 = 6;
+  int get dummy6() => g_(6);
+  bool hasDummy6() => h_(6);
+
+  // optional int32 dummy7 = 7;
+  int get dummy7() => g_(7);
+  bool hasDummy7() => h_(7);
+
+  // optional int32 dummy8 = 8;
+  int get dummy8() => g_(8);
+  bool hasDummy8() => h_(8);
+
+  // optional int32 dummy9 = 9;
+  int get dummy9() => g_(9);
+  bool hasDummy9() => h_(9);
+
+  // optional int32 dummy10 = 10;
+  int get dummy10() => g_(10);
+  bool hasDummy10() => h_(10);
+
+  // optional int32 dummy11 = 11;
+  int get dummy11() => g_(11);
+  bool hasDummy11() => h_(11);
+
+  // optional int32 dummy12 = 12;
+  int get dummy12() => g_(12);
+  bool hasDummy12() => h_(12);
+
+  // optional int32 dummy13 = 13;
+  int get dummy13() => g_(13);
+  bool hasDummy13() => h_(13);
+
+  // optional int32 dummy14 = 14;
+  int get dummy14() => g_(14);
+  bool hasDummy14() => h_(14);
+
+  // optional int32 dummy15 = 15;
+  int get dummy15() => g_(15);
+  bool hasDummy15() => h_(15);
+
+  // optional int32 dummy16 = 16;
+  int get dummy16() => g_(16);
+  bool hasDummy16() => h_(16);
+
+  // optional int32 dummy17 = 17;
+  int get dummy17() => g_(17);
+  bool hasDummy17() => h_(17);
+
+  // optional int32 dummy18 = 18;
+  int get dummy18() => g_(18);
+  bool hasDummy18() => h_(18);
+
+  // optional int32 dummy19 = 19;
+  int get dummy19() => g_(19);
+  bool hasDummy19() => h_(19);
+
+  // optional int32 dummy20 = 20;
+  int get dummy20() => g_(20);
+  bool hasDummy20() => h_(20);
+
+  // optional int32 dummy21 = 21;
+  int get dummy21() => g_(21);
+  bool hasDummy21() => h_(21);
+
+  // optional int32 dummy22 = 22;
+  int get dummy22() => g_(22);
+  bool hasDummy22() => h_(22);
+
+  // optional int32 dummy23 = 23;
+  int get dummy23() => g_(23);
+  bool hasDummy23() => h_(23);
+
+  // optional int32 dummy24 = 24;
+  int get dummy24() => g_(24);
+  bool hasDummy24() => h_(24);
+
+  // optional int32 dummy25 = 25;
+  int get dummy25() => g_(25);
+  bool hasDummy25() => h_(25);
+
+  // optional int32 dummy26 = 26;
+  int get dummy26() => g_(26);
+  bool hasDummy26() => h_(26);
+
+  // optional int32 dummy27 = 27;
+  int get dummy27() => g_(27);
+  bool hasDummy27() => h_(27);
+
+  // optional int32 dummy28 = 28;
+  int get dummy28() => g_(28);
+  bool hasDummy28() => h_(28);
+
+  // optional int32 dummy29 = 29;
+  int get dummy29() => g_(29);
+  bool hasDummy29() => h_(29);
+
+  // optional int32 dummy30 = 30;
+  int get dummy30() => g_(30);
+  bool hasDummy30() => h_(30);
+
+  // optional int32 dummy31 = 31;
+  int get dummy31() => g_(31);
+  bool hasDummy31() => h_(31);
+
+  // optional int32 dummy32 = 32;
+  int get dummy32() => g_(32);
+  bool hasDummy32() => h_(32);
+
+  // required int32 c = 33;
+  int get c() => g_(33);
+  bool hasC() => h_(33);
+}
+
+class Protobuf_Unittest_TestRequired_Builder extends Builder {
+  static BuilderInfo _i;
+
+  void initialize_() {
+    if (null == _i) {
+      _i = new BuilderInfo(this, "Protobuf_Unittest_TestRequired");
+      _i.a(1, 'a', Builder.Q3);
+      _i.a(2, 'dummy2', Builder.O3);
+      _i.a(3, 'b', Builder.Q3);
+      _i.a(4, 'dummy4', Builder.O3);
+      _i.a(5, 'dummy5', Builder.O3);
+      _i.a(6, 'dummy6', Builder.O3);
+      _i.a(7, 'dummy7', Builder.O3);
+      _i.a(8, 'dummy8', Builder.O3);
+      _i.a(9, 'dummy9', Builder.O3);
+      _i.a(10, 'dummy10', Builder.O3);
+      _i.a(11, 'dummy11', Builder.O3);
+      _i.a(12, 'dummy12', Builder.O3);
+      _i.a(13, 'dummy13', Builder.O3);
+      _i.a(14, 'dummy14', Builder.O3);
+      _i.a(15, 'dummy15', Builder.O3);
+      _i.a(16, 'dummy16', Builder.O3);
+      _i.a(17, 'dummy17', Builder.O3);
+      _i.a(18, 'dummy18', Builder.O3);
+      _i.a(19, 'dummy19', Builder.O3);
+      _i.a(20, 'dummy20', Builder.O3);
+      _i.a(21, 'dummy21', Builder.O3);
+      _i.a(22, 'dummy22', Builder.O3);
+      _i.a(23, 'dummy23', Builder.O3);
+      _i.a(24, 'dummy24', Builder.O3);
+      _i.a(25, 'dummy25', Builder.O3);
+      _i.a(26, 'dummy26', Builder.O3);
+      _i.a(27, 'dummy27', Builder.O3);
+      _i.a(28, 'dummy28', Builder.O3);
+      _i.a(29, 'dummy29', Builder.O3);
+      _i.a(30, 'dummy30', Builder.O3);
+      _i.a(31, 'dummy31', Builder.O3);
+      _i.a(32, 'dummy32', Builder.O3);
+      _i.a(33, 'c', Builder.Q3);
+    }
+  }
+
+  Protobuf_Unittest_TestRequired build() => super.build();
+  Protobuf_Unittest_TestRequired buildPartial() => partial(new Protobuf_Unittest_TestRequired._fromBuilder(this));
+  BuilderInfo get info_() => _i;
+
+  int get a() => g_(1);
+  void set a(int v) { s_(1, v); }
+  bool hasA() => h_(1);
+  void clearA() => c_(1);
+
+  int get dummy2() => g_(2);
+  void set dummy2(int v) { s_(2, v); }
+  bool hasDummy2() => h_(2);
+  void clearDummy2() => c_(2);
+
+  int get b() => g_(3);
+  void set b(int v) { s_(3, v); }
+  bool hasB() => h_(3);
+  void clearB() => c_(3);
+
+  int get dummy4() => g_(4);
+  void set dummy4(int v) { s_(4, v); }
+  bool hasDummy4() => h_(4);
+  void clearDummy4() => c_(4);
+
+  int get dummy5() => g_(5);
+  void set dummy5(int v) { s_(5, v); }
+  bool hasDummy5() => h_(5);
+  void clearDummy5() => c_(5);
+
+  int get dummy6() => g_(6);
+  void set dummy6(int v) { s_(6, v); }
+  bool hasDummy6() => h_(6);
+  void clearDummy6() => c_(6);
+
+  int get dummy7() => g_(7);
+  void set dummy7(int v) { s_(7, v); }
+  bool hasDummy7() => h_(7);
+  void clearDummy7() => c_(7);
+
+  int get dummy8() => g_(8);
+  void set dummy8(int v) { s_(8, v); }
+  bool hasDummy8() => h_(8);
+  void clearDummy8() => c_(8);
+
+  int get dummy9() => g_(9);
+  void set dummy9(int v) { s_(9, v); }
+  bool hasDummy9() => h_(9);
+  void clearDummy9() => c_(9);
+
+  int get dummy10() => g_(10);
+  void set dummy10(int v) { s_(10, v); }
+  bool hasDummy10() => h_(10);
+  void clearDummy10() => c_(10);
+
+  int get dummy11() => g_(11);
+  void set dummy11(int v) { s_(11, v); }
+  bool hasDummy11() => h_(11);
+  void clearDummy11() => c_(11);
+
+  int get dummy12() => g_(12);
+  void set dummy12(int v) { s_(12, v); }
+  bool hasDummy12() => h_(12);
+  void clearDummy12() => c_(12);
+
+  int get dummy13() => g_(13);
+  void set dummy13(int v) { s_(13, v); }
+  bool hasDummy13() => h_(13);
+  void clearDummy13() => c_(13);
+
+  int get dummy14() => g_(14);
+  void set dummy14(int v) { s_(14, v); }
+  bool hasDummy14() => h_(14);
+  void clearDummy14() => c_(14);
+
+  int get dummy15() => g_(15);
+  void set dummy15(int v) { s_(15, v); }
+  bool hasDummy15() => h_(15);
+  void clearDummy15() => c_(15);
+
+  int get dummy16() => g_(16);
+  void set dummy16(int v) { s_(16, v); }
+  bool hasDummy16() => h_(16);
+  void clearDummy16() => c_(16);
+
+  int get dummy17() => g_(17);
+  void set dummy17(int v) { s_(17, v); }
+  bool hasDummy17() => h_(17);
+  void clearDummy17() => c_(17);
+
+  int get dummy18() => g_(18);
+  void set dummy18(int v) { s_(18, v); }
+  bool hasDummy18() => h_(18);
+  void clearDummy18() => c_(18);
+
+  int get dummy19() => g_(19);
+  void set dummy19(int v) { s_(19, v); }
+  bool hasDummy19() => h_(19);
+  void clearDummy19() => c_(19);
+
+  int get dummy20() => g_(20);
+  void set dummy20(int v) { s_(20, v); }
+  bool hasDummy20() => h_(20);
+  void clearDummy20() => c_(20);
+
+  int get dummy21() => g_(21);
+  void set dummy21(int v) { s_(21, v); }
+  bool hasDummy21() => h_(21);
+  void clearDummy21() => c_(21);
+
+  int get dummy22() => g_(22);
+  void set dummy22(int v) { s_(22, v); }
+  bool hasDummy22() => h_(22);
+  void clearDummy22() => c_(22);
+
+  int get dummy23() => g_(23);
+  void set dummy23(int v) { s_(23, v); }
+  bool hasDummy23() => h_(23);
+  void clearDummy23() => c_(23);
+
+  int get dummy24() => g_(24);
+  void set dummy24(int v) { s_(24, v); }
+  bool hasDummy24() => h_(24);
+  void clearDummy24() => c_(24);
+
+  int get dummy25() => g_(25);
+  void set dummy25(int v) { s_(25, v); }
+  bool hasDummy25() => h_(25);
+  void clearDummy25() => c_(25);
+
+  int get dummy26() => g_(26);
+  void set dummy26(int v) { s_(26, v); }
+  bool hasDummy26() => h_(26);
+  void clearDummy26() => c_(26);
+
+  int get dummy27() => g_(27);
+  void set dummy27(int v) { s_(27, v); }
+  bool hasDummy27() => h_(27);
+  void clearDummy27() => c_(27);
+
+  int get dummy28() => g_(28);
+  void set dummy28(int v) { s_(28, v); }
+  bool hasDummy28() => h_(28);
+  void clearDummy28() => c_(28);
+
+  int get dummy29() => g_(29);
+  void set dummy29(int v) { s_(29, v); }
+  bool hasDummy29() => h_(29);
+  void clearDummy29() => c_(29);
+
+  int get dummy30() => g_(30);
+  void set dummy30(int v) { s_(30, v); }
+  bool hasDummy30() => h_(30);
+  void clearDummy30() => c_(30);
+
+  int get dummy31() => g_(31);
+  void set dummy31(int v) { s_(31, v); }
+  bool hasDummy31() => h_(31);
+  void clearDummy31() => c_(31);
+
+  int get dummy32() => g_(32);
+  void set dummy32(int v) { s_(32, v); }
+  bool hasDummy32() => h_(32);
+  void clearDummy32() => c_(32);
+
+  int get c() => g_(33);
+  void set c(int v) { s_(33, v); }
+  bool hasC() => h_(33);
+  void clearC() => c_(33);
+}
+
+class Protobuf_Unittest_TestRequiredForeign extends GeneratedMessage {
+  static Protobuf_Unittest_TestRequiredForeign _d;
+  static Protobuf_Unittest_TestRequiredForeign_Builder newBuilder() => new Protobuf_Unittest_TestRequiredForeign_Builder();
+  static Protobuf_Unittest_TestRequiredForeign get defaultInstance() => null == _d ? (_d = newBuilder().buildPartial()) : _d;
+  static Protobuf_Unittest_TestRequiredForeign parseFromBuffer(List<int> i, [ExtensionRegistry r]) => GeneratedMessage.parseBuffer(newBuilder(), i, r);
+  static Future<Protobuf_Unittest_TestRequiredForeign> parseFromStream(InputStream i, [ExtensionRegistry r]) => GeneratedMessage.parseStream(newBuilder(), i, r);
+  static Protobuf_Unittest_TestRequiredForeign parseFromJson(String i, [ExtensionRegistry r]) => GeneratedMessage.parseJson(newBuilder(), i, r);
+  Protobuf_Unittest_TestRequiredForeign._fromBuilder(Protobuf_Unittest_TestRequiredForeign_Builder b) : super(b);
+  Protobuf_Unittest_TestRequiredForeign_Builder toBuilder() => newBuilder().mergeFromMessage(this);
+
+  // optional protobuf_unittest.TestRequired optional_message = 1;
+  Protobuf_Unittest_TestRequired get optionalMessage() => g_(1);
+  bool hasOptionalMessage() => h_(1);
+
+  // repeated protobuf_unittest.TestRequired repeated_message = 2;
+  List<Protobuf_Unittest_TestRequired> get repeatedMessage() => g_(2);
+
+  // optional int32 dummy = 3;
+  int get dummy() => g_(3);
+  bool hasDummy() => h_(3);
+}
+
+class Protobuf_Unittest_TestRequiredForeign_Builder extends Builder {
+  static BuilderInfo _i;
+
+  void initialize_() {
+    if (null == _i) {
+      _i = new BuilderInfo(this, "Protobuf_Unittest_TestRequiredForeign");
+      _i.a(1, 'optionalMessage', Builder.OM, () => Protobuf_Unittest_TestRequired.defaultInstance, () => new Protobuf_Unittest_TestRequired_Builder());
+      _i.m(2, 'repeatedMessage', () => new Protobuf_Unittest_TestRequired_Builder(), () => new PbList<Protobuf_Unittest_TestRequired>(this));
+      _i.a(3, 'dummy', Builder.O3);
+    }
+  }
+
+  Protobuf_Unittest_TestRequiredForeign build() => super.build();
+  Protobuf_Unittest_TestRequiredForeign buildPartial() => partial(new Protobuf_Unittest_TestRequiredForeign._fromBuilder(this));
+  BuilderInfo get info_() => _i;
+
+  Protobuf_Unittest_TestRequired get optionalMessage() => g_(1);
+  void set optionalMessage(Protobuf_Unittest_TestRequired v) { s_(1, v); }
+  bool hasOptionalMessage() => h_(1);
+  void clearOptionalMessage() => c_(1);
+
+  List<Protobuf_Unittest_TestRequired> get repeatedMessage() => g_(2);
+
+  int get dummy() => g_(3);
+  void set dummy(int v) { s_(3, v); }
+  bool hasDummy() => h_(3);
+  void clearDummy() => c_(3);
+}
+
+class Protobuf_Unittest_TestForeignNested extends GeneratedMessage {
+  static Protobuf_Unittest_TestForeignNested _d;
+  static Protobuf_Unittest_TestForeignNested_Builder newBuilder() => new Protobuf_Unittest_TestForeignNested_Builder();
+  static Protobuf_Unittest_TestForeignNested get defaultInstance() => null == _d ? (_d = newBuilder().buildPartial()) : _d;
+  static Protobuf_Unittest_TestForeignNested parseFromBuffer(List<int> i, [ExtensionRegistry r]) => GeneratedMessage.parseBuffer(newBuilder(), i, r);
+  static Future<Protobuf_Unittest_TestForeignNested> parseFromStream(InputStream i, [ExtensionRegistry r]) => GeneratedMessage.parseStream(newBuilder(), i, r);
+  static Protobuf_Unittest_TestForeignNested parseFromJson(String i, [ExtensionRegistry r]) => GeneratedMessage.parseJson(newBuilder(), i, r);
+  Protobuf_Unittest_TestForeignNested._fromBuilder(Protobuf_Unittest_TestForeignNested_Builder b) : super(b);
+  Protobuf_Unittest_TestForeignNested_Builder toBuilder() => newBuilder().mergeFromMessage(this);
+
+  // optional protobuf_unittest.TestAllTypes.NestedMessage foreign_nested = 1;
+  Protobuf_Unittest_TestAllTypes_NestedMessage get foreignNested() => g_(1);
+  bool hasForeignNested() => h_(1);
+}
+
+class Protobuf_Unittest_TestForeignNested_Builder extends Builder {
+  static BuilderInfo _i;
+
+  void initialize_() {
+    if (null == _i) {
+      _i = new BuilderInfo(this, "Protobuf_Unittest_TestForeignNested");
+      _i.a(1, 'foreignNested', Builder.OM, () => Protobuf_Unittest_TestAllTypes_NestedMessage.defaultInstance, () => new Protobuf_Unittest_TestAllTypes_NestedMessage_Builder());
+      _i.hasRequiredFields = false;
+    }
+  }
+
+  Protobuf_Unittest_TestForeignNested build() => super.build();
+  Protobuf_Unittest_TestForeignNested buildPartial() => partial(new Protobuf_Unittest_TestForeignNested._fromBuilder(this));
+  BuilderInfo get info_() => _i;
+
+  Protobuf_Unittest_TestAllTypes_NestedMessage get foreignNested() => g_(1);
+  void set foreignNested(Protobuf_Unittest_TestAllTypes_NestedMessage v) { s_(1, v); }
+  bool hasForeignNested() => h_(1);
+  void clearForeignNested() => c_(1);
+}
+
+class Protobuf_Unittest_TestEmptyMessage extends GeneratedMessage {
+  static Protobuf_Unittest_TestEmptyMessage _d;
+  static Protobuf_Unittest_TestEmptyMessage_Builder newBuilder() => new Protobuf_Unittest_TestEmptyMessage_Builder();
+  static Protobuf_Unittest_TestEmptyMessage get defaultInstance() => null == _d ? (_d = newBuilder().buildPartial()) : _d;
+  static Protobuf_Unittest_TestEmptyMessage parseFromBuffer(List<int> i, [ExtensionRegistry r]) => GeneratedMessage.parseBuffer(newBuilder(), i, r);
+  static Future<Protobuf_Unittest_TestEmptyMessage> parseFromStream(InputStream i, [ExtensionRegistry r]) => GeneratedMessage.parseStream(newBuilder(), i, r);
+  static Protobuf_Unittest_TestEmptyMessage parseFromJson(String i, [ExtensionRegistry r]) => GeneratedMessage.parseJson(newBuilder(), i, r);
+  Protobuf_Unittest_TestEmptyMessage._fromBuilder(Protobuf_Unittest_TestEmptyMessage_Builder b) : super(b);
+  Protobuf_Unittest_TestEmptyMessage_Builder toBuilder() => newBuilder().mergeFromMessage(this);
+}
+
+class Protobuf_Unittest_TestEmptyMessage_Builder extends Builder {
+  static BuilderInfo _i;
+
+  void initialize_() {
+    if (null == _i) {
+      _i = new BuilderInfo(this, "Protobuf_Unittest_TestEmptyMessage");
+      _i.hasRequiredFields = false;
+    }
+  }
+
+  Protobuf_Unittest_TestEmptyMessage build() => super.build();
+  Protobuf_Unittest_TestEmptyMessage buildPartial() => partial(new Protobuf_Unittest_TestEmptyMessage._fromBuilder(this));
+  BuilderInfo get info_() => _i;
+}
+
+class Protobuf_Unittest_TestEmptyMessageWithExtensions extends GeneratedMessage {
+  static Protobuf_Unittest_TestEmptyMessageWithExtensions _d;
+  static Protobuf_Unittest_TestEmptyMessageWithExtensions_Builder newBuilder() => new Protobuf_Unittest_TestEmptyMessageWithExtensions_Builder();
+  static Protobuf_Unittest_TestEmptyMessageWithExtensions get defaultInstance() => null == _d ? (_d = newBuilder().buildPartial()) : _d;
+  static Protobuf_Unittest_TestEmptyMessageWithExtensions parseFromBuffer(List<int> i, [ExtensionRegistry r]) => GeneratedMessage.parseBuffer(newBuilder(), i, r);
+  static Future<Protobuf_Unittest_TestEmptyMessageWithExtensions> parseFromStream(InputStream i, [ExtensionRegistry r]) => GeneratedMessage.parseStream(newBuilder(), i, r);
+  static Protobuf_Unittest_TestEmptyMessageWithExtensions parseFromJson(String i, [ExtensionRegistry r]) => GeneratedMessage.parseJson(newBuilder(), i, r);
+  Protobuf_Unittest_TestEmptyMessageWithExtensions._fromBuilder(Protobuf_Unittest_TestEmptyMessageWithExtensions_Builder b) : super(b);
+  Protobuf_Unittest_TestEmptyMessageWithExtensions_Builder toBuilder() => newBuilder().mergeFromMessage(this);
+}
+
+class Protobuf_Unittest_TestEmptyMessageWithExtensions_Builder extends Builder {
+  static BuilderInfo _i;
+
+  void initialize_() {
+    if (null == _i) {
+      _i = new BuilderInfo(this, "Protobuf_Unittest_TestEmptyMessageWithExtensions");
+      _i.hasExtensions = true;
+    }
+  }
+
+  Protobuf_Unittest_TestEmptyMessageWithExtensions build() => super.build();
+  Protobuf_Unittest_TestEmptyMessageWithExtensions buildPartial() => partial(new Protobuf_Unittest_TestEmptyMessageWithExtensions._fromBuilder(this));
+  BuilderInfo get info_() => _i;
+}
+
+class Protobuf_Unittest_TestMultipleExtensionRanges extends GeneratedMessage {
+  static Protobuf_Unittest_TestMultipleExtensionRanges _d;
+  static Protobuf_Unittest_TestMultipleExtensionRanges_Builder newBuilder() => new Protobuf_Unittest_TestMultipleExtensionRanges_Builder();
+  static Protobuf_Unittest_TestMultipleExtensionRanges get defaultInstance() => null == _d ? (_d = newBuilder().buildPartial()) : _d;
+  static Protobuf_Unittest_TestMultipleExtensionRanges parseFromBuffer(List<int> i, [ExtensionRegistry r]) => GeneratedMessage.parseBuffer(newBuilder(), i, r);
+  static Future<Protobuf_Unittest_TestMultipleExtensionRanges> parseFromStream(InputStream i, [ExtensionRegistry r]) => GeneratedMessage.parseStream(newBuilder(), i, r);
+  static Protobuf_Unittest_TestMultipleExtensionRanges parseFromJson(String i, [ExtensionRegistry r]) => GeneratedMessage.parseJson(newBuilder(), i, r);
+  Protobuf_Unittest_TestMultipleExtensionRanges._fromBuilder(Protobuf_Unittest_TestMultipleExtensionRanges_Builder b) : super(b);
+  Protobuf_Unittest_TestMultipleExtensionRanges_Builder toBuilder() => newBuilder().mergeFromMessage(this);
+}
+
+class Protobuf_Unittest_TestMultipleExtensionRanges_Builder extends Builder {
+  static BuilderInfo _i;
+
+  void initialize_() {
+    if (null == _i) {
+      _i = new BuilderInfo(this, "Protobuf_Unittest_TestMultipleExtensionRanges");
+      _i.hasExtensions = true;
+    }
+  }
+
+  Protobuf_Unittest_TestMultipleExtensionRanges build() => super.build();
+  Protobuf_Unittest_TestMultipleExtensionRanges buildPartial() => partial(new Protobuf_Unittest_TestMultipleExtensionRanges._fromBuilder(this));
+  BuilderInfo get info_() => _i;
+}
+
+class Protobuf_Unittest_TestReallyLargeTagNumber extends GeneratedMessage {
+  static Protobuf_Unittest_TestReallyLargeTagNumber _d;
+  static Protobuf_Unittest_TestReallyLargeTagNumber_Builder newBuilder() => new Protobuf_Unittest_TestReallyLargeTagNumber_Builder();
+  static Protobuf_Unittest_TestReallyLargeTagNumber get defaultInstance() => null == _d ? (_d = newBuilder().buildPartial()) : _d;
+  static Protobuf_Unittest_TestReallyLargeTagNumber parseFromBuffer(List<int> i, [ExtensionRegistry r]) => GeneratedMessage.parseBuffer(newBuilder(), i, r);
+  static Future<Protobuf_Unittest_TestReallyLargeTagNumber> parseFromStream(InputStream i, [ExtensionRegistry r]) => GeneratedMessage.parseStream(newBuilder(), i, r);
+  static Protobuf_Unittest_TestReallyLargeTagNumber parseFromJson(String i, [ExtensionRegistry r]) => GeneratedMessage.parseJson(newBuilder(), i, r);
+  Protobuf_Unittest_TestReallyLargeTagNumber._fromBuilder(Protobuf_Unittest_TestReallyLargeTagNumber_Builder b) : super(b);
+  Protobuf_Unittest_TestReallyLargeTagNumber_Builder toBuilder() => newBuilder().mergeFromMessage(this);
+
+  // optional int32 a = 1;
+  int get a() => g_(1);
+  bool hasA() => h_(1);
+
+  // optional int32 bb = 268435455;
+  int get bb() => g_(268435455);
+  bool hasBb() => h_(268435455);
+}
+
+class Protobuf_Unittest_TestReallyLargeTagNumber_Builder extends Builder {
+  static BuilderInfo _i;
+
+  void initialize_() {
+    if (null == _i) {
+      _i = new BuilderInfo(this, "Protobuf_Unittest_TestReallyLargeTagNumber");
+      _i.a(1, 'a', Builder.O3);
+      _i.a(268435455, 'bb', Builder.O3);
+      _i.hasRequiredFields = false;
+    }
+  }
+
+  Protobuf_Unittest_TestReallyLargeTagNumber build() => super.build();
+  Protobuf_Unittest_TestReallyLargeTagNumber buildPartial() => partial(new Protobuf_Unittest_TestReallyLargeTagNumber._fromBuilder(this));
+  BuilderInfo get info_() => _i;
+
+  int get a() => g_(1);
+  void set a(int v) { s_(1, v); }
+  bool hasA() => h_(1);
+  void clearA() => c_(1);
+
+  int get bb() => g_(268435455);
+  void set bb(int v) { s_(268435455, v); }
+  bool hasBb() => h_(268435455);
+  void clearBb() => c_(268435455);
+}
+
+class Protobuf_Unittest_TestRecursiveMessage extends GeneratedMessage {
+  static Protobuf_Unittest_TestRecursiveMessage _d;
+  static Protobuf_Unittest_TestRecursiveMessage_Builder newBuilder() => new Protobuf_Unittest_TestRecursiveMessage_Builder();
+  static Protobuf_Unittest_TestRecursiveMessage get defaultInstance() => null == _d ? (_d = newBuilder().buildPartial()) : _d;
+  static Protobuf_Unittest_TestRecursiveMessage parseFromBuffer(List<int> i, [ExtensionRegistry r]) => GeneratedMessage.parseBuffer(newBuilder(), i, r);
+  static Future<Protobuf_Unittest_TestRecursiveMessage> parseFromStream(InputStream i, [ExtensionRegistry r]) => GeneratedMessage.parseStream(newBuilder(), i, r);
+  static Protobuf_Unittest_TestRecursiveMessage parseFromJson(String i, [ExtensionRegistry r]) => GeneratedMessage.parseJson(newBuilder(), i, r);
+  Protobuf_Unittest_TestRecursiveMessage._fromBuilder(Protobuf_Unittest_TestRecursiveMessage_Builder b) : super(b);
+  Protobuf_Unittest_TestRecursiveMessage_Builder toBuilder() => newBuilder().mergeFromMessage(this);
+
+  // optional protobuf_unittest.TestRecursiveMessage a = 1;
+  Protobuf_Unittest_TestRecursiveMessage get a() => g_(1);
+  bool hasA() => h_(1);
+
+  // optional int32 i = 2;
+  int get i() => g_(2);
+  bool hasI() => h_(2);
+}
+
+class Protobuf_Unittest_TestRecursiveMessage_Builder extends Builder {
+  static BuilderInfo _i;
+
+  void initialize_() {
+    if (null == _i) {
+      _i = new BuilderInfo(this, "Protobuf_Unittest_TestRecursiveMessage");
+      _i.a(1, 'a', Builder.OM, () => Protobuf_Unittest_TestRecursiveMessage.defaultInstance, () => new Protobuf_Unittest_TestRecursiveMessage_Builder());
+      _i.a(2, 'i', Builder.O3);
+      _i.hasRequiredFields = false;
+    }
+  }
+
+  Protobuf_Unittest_TestRecursiveMessage build() => super.build();
+  Protobuf_Unittest_TestRecursiveMessage buildPartial() => partial(new Protobuf_Unittest_TestRecursiveMessage._fromBuilder(this));
+  BuilderInfo get info_() => _i;
+
+  Protobuf_Unittest_TestRecursiveMessage get a() => g_(1);
+  void set a(Protobuf_Unittest_TestRecursiveMessage v) { s_(1, v); }
+  bool hasA() => h_(1);
+  void clearA() => c_(1);
+
+  int get i() => g_(2);
+  void set i(int v) { s_(2, v); }
+  bool hasI() => h_(2);
+  void clearI() => c_(2);
+}
+
+class Protobuf_Unittest_TestMutualRecursionA extends GeneratedMessage {
+  static Protobuf_Unittest_TestMutualRecursionA _d;
+  static Protobuf_Unittest_TestMutualRecursionA_Builder newBuilder() => new Protobuf_Unittest_TestMutualRecursionA_Builder();
+  static Protobuf_Unittest_TestMutualRecursionA get defaultInstance() => null == _d ? (_d = newBuilder().buildPartial()) : _d;
+  static Protobuf_Unittest_TestMutualRecursionA parseFromBuffer(List<int> i, [ExtensionRegistry r]) => GeneratedMessage.parseBuffer(newBuilder(), i, r);
+  static Future<Protobuf_Unittest_TestMutualRecursionA> parseFromStream(InputStream i, [ExtensionRegistry r]) => GeneratedMessage.parseStream(newBuilder(), i, r);
+  static Protobuf_Unittest_TestMutualRecursionA parseFromJson(String i, [ExtensionRegistry r]) => GeneratedMessage.parseJson(newBuilder(), i, r);
+  Protobuf_Unittest_TestMutualRecursionA._fromBuilder(Protobuf_Unittest_TestMutualRecursionA_Builder b) : super(b);
+  Protobuf_Unittest_TestMutualRecursionA_Builder toBuilder() => newBuilder().mergeFromMessage(this);
+
+  // optional protobuf_unittest.TestMutualRecursionB bb = 1;
+  Protobuf_Unittest_TestMutualRecursionB get bb() => g_(1);
+  bool hasBb() => h_(1);
+}
+
+class Protobuf_Unittest_TestMutualRecursionA_Builder extends Builder {
+  static BuilderInfo _i;
+
+  void initialize_() {
+    if (null == _i) {
+      _i = new BuilderInfo(this, "Protobuf_Unittest_TestMutualRecursionA");
+      _i.a(1, 'bb', Builder.OM, () => Protobuf_Unittest_TestMutualRecursionB.defaultInstance, () => new Protobuf_Unittest_TestMutualRecursionB_Builder());
+      _i.hasRequiredFields = false;
+    }
+  }
+
+  Protobuf_Unittest_TestMutualRecursionA build() => super.build();
+  Protobuf_Unittest_TestMutualRecursionA buildPartial() => partial(new Protobuf_Unittest_TestMutualRecursionA._fromBuilder(this));
+  BuilderInfo get info_() => _i;
+
+  Protobuf_Unittest_TestMutualRecursionB get bb() => g_(1);
+  void set bb(Protobuf_Unittest_TestMutualRecursionB v) { s_(1, v); }
+  bool hasBb() => h_(1);
+  void clearBb() => c_(1);
+}
+
+class Protobuf_Unittest_TestMutualRecursionB extends GeneratedMessage {
+  static Protobuf_Unittest_TestMutualRecursionB _d;
+  static Protobuf_Unittest_TestMutualRecursionB_Builder newBuilder() => new Protobuf_Unittest_TestMutualRecursionB_Builder();
+  static Protobuf_Unittest_TestMutualRecursionB get defaultInstance() => null == _d ? (_d = newBuilder().buildPartial()) : _d;
+  static Protobuf_Unittest_TestMutualRecursionB parseFromBuffer(List<int> i, [ExtensionRegistry r]) => GeneratedMessage.parseBuffer(newBuilder(), i, r);
+  static Future<Protobuf_Unittest_TestMutualRecursionB> parseFromStream(InputStream i, [ExtensionRegistry r]) => GeneratedMessage.parseStream(newBuilder(), i, r);
+  static Protobuf_Unittest_TestMutualRecursionB parseFromJson(String i, [ExtensionRegistry r]) => GeneratedMessage.parseJson(newBuilder(), i, r);
+  Protobuf_Unittest_TestMutualRecursionB._fromBuilder(Protobuf_Unittest_TestMutualRecursionB_Builder b) : super(b);
+  Protobuf_Unittest_TestMutualRecursionB_Builder toBuilder() => newBuilder().mergeFromMessage(this);
+
+  // optional protobuf_unittest.TestMutualRecursionA a = 1;
+  Protobuf_Unittest_TestMutualRecursionA get a() => g_(1);
+  bool hasA() => h_(1);
+
+  // optional int32 optional_int32 = 2;
+  int get optionalInt32() => g_(2);
+  bool hasOptionalInt32() => h_(2);
+}
+
+class Protobuf_Unittest_TestMutualRecursionB_Builder extends Builder {
+  static BuilderInfo _i;
+
+  void initialize_() {
+    if (null == _i) {
+      _i = new BuilderInfo(this, "Protobuf_Unittest_TestMutualRecursionB");
+      _i.a(1, 'a', Builder.OM, () => Protobuf_Unittest_TestMutualRecursionA.defaultInstance, () => new Protobuf_Unittest_TestMutualRecursionA_Builder());
+      _i.a(2, 'optionalInt32', Builder.O3);
+      _i.hasRequiredFields = false;
+    }
+  }
+
+  Protobuf_Unittest_TestMutualRecursionB build() => super.build();
+  Protobuf_Unittest_TestMutualRecursionB buildPartial() => partial(new Protobuf_Unittest_TestMutualRecursionB._fromBuilder(this));
+  BuilderInfo get info_() => _i;
+
+  Protobuf_Unittest_TestMutualRecursionA get a() => g_(1);
+  void set a(Protobuf_Unittest_TestMutualRecursionA v) { s_(1, v); }
+  bool hasA() => h_(1);
+  void clearA() => c_(1);
+
+  int get optionalInt32() => g_(2);
+  void set optionalInt32(int v) { s_(2, v); }
+  bool hasOptionalInt32() => h_(2);
+  void clearOptionalInt32() => c_(2);
+}
+
+class Protobuf_Unittest_TestDupFieldNumber_Foo extends GeneratedMessage {
+  static Protobuf_Unittest_TestDupFieldNumber_Foo _d;
+  static Protobuf_Unittest_TestDupFieldNumber_Foo_Builder newBuilder() => new Protobuf_Unittest_TestDupFieldNumber_Foo_Builder();
+  static Protobuf_Unittest_TestDupFieldNumber_Foo get defaultInstance() => null == _d ? (_d = newBuilder().buildPartial()) : _d;
+  static Protobuf_Unittest_TestDupFieldNumber_Foo parseFromBuffer(List<int> i, [ExtensionRegistry r]) => GeneratedMessage.parseBuffer(newBuilder(), i, r);
+  static Future<Protobuf_Unittest_TestDupFieldNumber_Foo> parseFromStream(InputStream i, [ExtensionRegistry r]) => GeneratedMessage.parseStream(newBuilder(), i, r);
+  static Protobuf_Unittest_TestDupFieldNumber_Foo parseFromJson(String i, [ExtensionRegistry r]) => GeneratedMessage.parseJson(newBuilder(), i, r);
+  Protobuf_Unittest_TestDupFieldNumber_Foo._fromBuilder(Protobuf_Unittest_TestDupFieldNumber_Foo_Builder b) : super(b);
+  Protobuf_Unittest_TestDupFieldNumber_Foo_Builder toBuilder() => newBuilder().mergeFromMessage(this);
+
+  // optional int32 a = 1;
+  int get a() => g_(1);
+  bool hasA() => h_(1);
+}
+
+class Protobuf_Unittest_TestDupFieldNumber_Foo_Builder extends Builder {
+  static BuilderInfo _i;
+
+  void initialize_() {
+    if (null == _i) {
+      _i = new BuilderInfo(this, "Protobuf_Unittest_TestDupFieldNumber_Foo");
+      _i.a(1, 'a', Builder.O3);
+      _i.hasRequiredFields = false;
+    }
+  }
+
+  Protobuf_Unittest_TestDupFieldNumber_Foo build() => super.build();
+  Protobuf_Unittest_TestDupFieldNumber_Foo buildPartial() => partial(new Protobuf_Unittest_TestDupFieldNumber_Foo._fromBuilder(this));
+  BuilderInfo get info_() => _i;
+
+  int get a() => g_(1);
+  void set a(int v) { s_(1, v); }
+  bool hasA() => h_(1);
+  void clearA() => c_(1);
+}
+
+class Protobuf_Unittest_TestDupFieldNumber_Bar extends GeneratedMessage {
+  static Protobuf_Unittest_TestDupFieldNumber_Bar _d;
+  static Protobuf_Unittest_TestDupFieldNumber_Bar_Builder newBuilder() => new Protobuf_Unittest_TestDupFieldNumber_Bar_Builder();
+  static Protobuf_Unittest_TestDupFieldNumber_Bar get defaultInstance() => null == _d ? (_d = newBuilder().buildPartial()) : _d;
+  static Protobuf_Unittest_TestDupFieldNumber_Bar parseFromBuffer(List<int> i, [ExtensionRegistry r]) => GeneratedMessage.parseBuffer(newBuilder(), i, r);
+  static Future<Protobuf_Unittest_TestDupFieldNumber_Bar> parseFromStream(InputStream i, [ExtensionRegistry r]) => GeneratedMessage.parseStream(newBuilder(), i, r);
+  static Protobuf_Unittest_TestDupFieldNumber_Bar parseFromJson(String i, [ExtensionRegistry r]) => GeneratedMessage.parseJson(newBuilder(), i, r);
+  Protobuf_Unittest_TestDupFieldNumber_Bar._fromBuilder(Protobuf_Unittest_TestDupFieldNumber_Bar_Builder b) : super(b);
+  Protobuf_Unittest_TestDupFieldNumber_Bar_Builder toBuilder() => newBuilder().mergeFromMessage(this);
+
+  // optional int32 a = 1;
+  int get a() => g_(1);
+  bool hasA() => h_(1);
+}
+
+class Protobuf_Unittest_TestDupFieldNumber_Bar_Builder extends Builder {
+  static BuilderInfo _i;
+
+  void initialize_() {
+    if (null == _i) {
+      _i = new BuilderInfo(this, "Protobuf_Unittest_TestDupFieldNumber_Bar");
+      _i.a(1, 'a', Builder.O3);
+      _i.hasRequiredFields = false;
+    }
+  }
+
+  Protobuf_Unittest_TestDupFieldNumber_Bar build() => super.build();
+  Protobuf_Unittest_TestDupFieldNumber_Bar buildPartial() => partial(new Protobuf_Unittest_TestDupFieldNumber_Bar._fromBuilder(this));
+  BuilderInfo get info_() => _i;
+
+  int get a() => g_(1);
+  void set a(int v) { s_(1, v); }
+  bool hasA() => h_(1);
+  void clearA() => c_(1);
+}
+
+class Protobuf_Unittest_TestDupFieldNumber extends GeneratedMessage {
+  static Protobuf_Unittest_TestDupFieldNumber _d;
+  static Protobuf_Unittest_TestDupFieldNumber_Builder newBuilder() => new Protobuf_Unittest_TestDupFieldNumber_Builder();
+  static Protobuf_Unittest_TestDupFieldNumber get defaultInstance() => null == _d ? (_d = newBuilder().buildPartial()) : _d;
+  static Protobuf_Unittest_TestDupFieldNumber parseFromBuffer(List<int> i, [ExtensionRegistry r]) => GeneratedMessage.parseBuffer(newBuilder(), i, r);
+  static Future<Protobuf_Unittest_TestDupFieldNumber> parseFromStream(InputStream i, [ExtensionRegistry r]) => GeneratedMessage.parseStream(newBuilder(), i, r);
+  static Protobuf_Unittest_TestDupFieldNumber parseFromJson(String i, [ExtensionRegistry r]) => GeneratedMessage.parseJson(newBuilder(), i, r);
+  Protobuf_Unittest_TestDupFieldNumber._fromBuilder(Protobuf_Unittest_TestDupFieldNumber_Builder b) : super(b);
+  Protobuf_Unittest_TestDupFieldNumber_Builder toBuilder() => newBuilder().mergeFromMessage(this);
+
+  // optional int32 a = 1;
+  int get a() => g_(1);
+  bool hasA() => h_(1);
+
+  // optional protobuf_unittest.TestDupFieldNumber.Foo foo = 2;
+  Protobuf_Unittest_TestDupFieldNumber_Foo get foo() => g_(2);
+  bool hasFoo() => h_(2);
+
+  // optional protobuf_unittest.TestDupFieldNumber.Bar bar = 3;
+  Protobuf_Unittest_TestDupFieldNumber_Bar get bar() => g_(3);
+  bool hasBar() => h_(3);
+}
+
+class Protobuf_Unittest_TestDupFieldNumber_Builder extends Builder {
+  static BuilderInfo _i;
+
+  void initialize_() {
+    if (null == _i) {
+      _i = new BuilderInfo(this, "Protobuf_Unittest_TestDupFieldNumber");
+      _i.a(1, 'a', Builder.O3);
+      _i.a(2, 'foo', Builder.OG, () => Protobuf_Unittest_TestDupFieldNumber_Foo.defaultInstance, () => new Protobuf_Unittest_TestDupFieldNumber_Foo_Builder());
+      _i.a(3, 'bar', Builder.OG, () => Protobuf_Unittest_TestDupFieldNumber_Bar.defaultInstance, () => new Protobuf_Unittest_TestDupFieldNumber_Bar_Builder());
+      _i.hasRequiredFields = false;
+    }
+  }
+
+  Protobuf_Unittest_TestDupFieldNumber build() => super.build();
+  Protobuf_Unittest_TestDupFieldNumber buildPartial() => partial(new Protobuf_Unittest_TestDupFieldNumber._fromBuilder(this));
+  BuilderInfo get info_() => _i;
+
+  int get a() => g_(1);
+  void set a(int v) { s_(1, v); }
+  bool hasA() => h_(1);
+  void clearA() => c_(1);
+
+  Protobuf_Unittest_TestDupFieldNumber_Foo get foo() => g_(2);
+  void set foo(Protobuf_Unittest_TestDupFieldNumber_Foo v) { s_(2, v); }
+  bool hasFoo() => h_(2);
+  void clearFoo() => c_(2);
+
+  Protobuf_Unittest_TestDupFieldNumber_Bar get bar() => g_(3);
+  void set bar(Protobuf_Unittest_TestDupFieldNumber_Bar v) { s_(3, v); }
+  bool hasBar() => h_(3);
+  void clearBar() => c_(3);
+}
+
+class Protobuf_Unittest_TestNestedMessageHasBits_NestedMessage extends GeneratedMessage {
+  static Protobuf_Unittest_TestNestedMessageHasBits_NestedMessage _d;
+  static Protobuf_Unittest_TestNestedMessageHasBits_NestedMessage_Builder newBuilder() => new Protobuf_Unittest_TestNestedMessageHasBits_NestedMessage_Builder();
+  static Protobuf_Unittest_TestNestedMessageHasBits_NestedMessage get defaultInstance() => null == _d ? (_d = newBuilder().buildPartial()) : _d;
+  static Protobuf_Unittest_TestNestedMessageHasBits_NestedMessage parseFromBuffer(List<int> i, [ExtensionRegistry r]) => GeneratedMessage.parseBuffer(newBuilder(), i, r);
+  static Future<Protobuf_Unittest_TestNestedMessageHasBits_NestedMessage> parseFromStream(InputStream i, [ExtensionRegistry r]) => GeneratedMessage.parseStream(newBuilder(), i, r);
+  static Protobuf_Unittest_TestNestedMessageHasBits_NestedMessage parseFromJson(String i, [ExtensionRegistry r]) => GeneratedMessage.parseJson(newBuilder(), i, r);
+  Protobuf_Unittest_TestNestedMessageHasBits_NestedMessage._fromBuilder(Protobuf_Unittest_TestNestedMessageHasBits_NestedMessage_Builder b) : super(b);
+  Protobuf_Unittest_TestNestedMessageHasBits_NestedMessage_Builder toBuilder() => newBuilder().mergeFromMessage(this);
+
+  // repeated int32 nestedmessage_repeated_int32 = 1;
+  List<int> get nestedmessageRepeatedInt32() => g_(1);
+
+  // repeated protobuf_unittest.ForeignMessage nestedmessage_repeated_foreignmessage = 2;
+  List<Protobuf_Unittest_ForeignMessage> get nestedmessageRepeatedForeignmessage() => g_(2);
+}
+
+class Protobuf_Unittest_TestNestedMessageHasBits_NestedMessage_Builder extends Builder {
+  static BuilderInfo _i;
+
+  void initialize_() {
+    if (null == _i) {
+      _i = new BuilderInfo(this, "Protobuf_Unittest_TestNestedMessageHasBits_NestedMessage");
+      _i.p(1, 'nestedmessageRepeatedInt32', Builder.P3);
+      _i.m(2, 'nestedmessageRepeatedForeignmessage', () => new Protobuf_Unittest_ForeignMessage_Builder(), () => new PbList<Protobuf_Unittest_ForeignMessage>(this));
+      _i.hasRequiredFields = false;
+    }
+  }
+
+  Protobuf_Unittest_TestNestedMessageHasBits_NestedMessage build() => super.build();
+  Protobuf_Unittest_TestNestedMessageHasBits_NestedMessage buildPartial() => partial(new Protobuf_Unittest_TestNestedMessageHasBits_NestedMessage._fromBuilder(this));
+  BuilderInfo get info_() => _i;
+
+  List<int> get nestedmessageRepeatedInt32() => g_(1);
+
+  List<Protobuf_Unittest_ForeignMessage> get nestedmessageRepeatedForeignmessage() => g_(2);
+}
+
+class Protobuf_Unittest_TestNestedMessageHasBits extends GeneratedMessage {
+  static Protobuf_Unittest_TestNestedMessageHasBits _d;
+  static Protobuf_Unittest_TestNestedMessageHasBits_Builder newBuilder() => new Protobuf_Unittest_TestNestedMessageHasBits_Builder();
+  static Protobuf_Unittest_TestNestedMessageHasBits get defaultInstance() => null == _d ? (_d = newBuilder().buildPartial()) : _d;
+  static Protobuf_Unittest_TestNestedMessageHasBits parseFromBuffer(List<int> i, [ExtensionRegistry r]) => GeneratedMessage.parseBuffer(newBuilder(), i, r);
+  static Future<Protobuf_Unittest_TestNestedMessageHasBits> parseFromStream(InputStream i, [ExtensionRegistry r]) => GeneratedMessage.parseStream(newBuilder(), i, r);
+  static Protobuf_Unittest_TestNestedMessageHasBits parseFromJson(String i, [ExtensionRegistry r]) => GeneratedMessage.parseJson(newBuilder(), i, r);
+  Protobuf_Unittest_TestNestedMessageHasBits._fromBuilder(Protobuf_Unittest_TestNestedMessageHasBits_Builder b) : super(b);
+  Protobuf_Unittest_TestNestedMessageHasBits_Builder toBuilder() => newBuilder().mergeFromMessage(this);
+
+  // optional protobuf_unittest.TestNestedMessageHasBits.NestedMessage optional_nested_message = 1;
+  Protobuf_Unittest_TestNestedMessageHasBits_NestedMessage get optionalNestedMessage() => g_(1);
+  bool hasOptionalNestedMessage() => h_(1);
+}
+
+class Protobuf_Unittest_TestNestedMessageHasBits_Builder extends Builder {
+  static BuilderInfo _i;
+
+  void initialize_() {
+    if (null == _i) {
+      _i = new BuilderInfo(this, "Protobuf_Unittest_TestNestedMessageHasBits");
+      _i.a(1, 'optionalNestedMessage', Builder.OM, () => Protobuf_Unittest_TestNestedMessageHasBits_NestedMessage.defaultInstance, () => new Protobuf_Unittest_TestNestedMessageHasBits_NestedMessage_Builder());
+      _i.hasRequiredFields = false;
+    }
+  }
+
+  Protobuf_Unittest_TestNestedMessageHasBits build() => super.build();
+  Protobuf_Unittest_TestNestedMessageHasBits buildPartial() => partial(new Protobuf_Unittest_TestNestedMessageHasBits._fromBuilder(this));
+  BuilderInfo get info_() => _i;
+
+  Protobuf_Unittest_TestNestedMessageHasBits_NestedMessage get optionalNestedMessage() => g_(1);
+  void set optionalNestedMessage(Protobuf_Unittest_TestNestedMessageHasBits_NestedMessage v) { s_(1, v); }
+  bool hasOptionalNestedMessage() => h_(1);
+  void clearOptionalNestedMessage() => c_(1);
+}
+
+class Protobuf_Unittest_TestCamelCaseFieldNames extends GeneratedMessage {
+  static Protobuf_Unittest_TestCamelCaseFieldNames _d;
+  static Protobuf_Unittest_TestCamelCaseFieldNames_Builder newBuilder() => new Protobuf_Unittest_TestCamelCaseFieldNames_Builder();
+  static Protobuf_Unittest_TestCamelCaseFieldNames get defaultInstance() => null == _d ? (_d = newBuilder().buildPartial()) : _d;
+  static Protobuf_Unittest_TestCamelCaseFieldNames parseFromBuffer(List<int> i, [ExtensionRegistry r]) => GeneratedMessage.parseBuffer(newBuilder(), i, r);
+  static Future<Protobuf_Unittest_TestCamelCaseFieldNames> parseFromStream(InputStream i, [ExtensionRegistry r]) => GeneratedMessage.parseStream(newBuilder(), i, r);
+  static Protobuf_Unittest_TestCamelCaseFieldNames parseFromJson(String i, [ExtensionRegistry r]) => GeneratedMessage.parseJson(newBuilder(), i, r);
+  Protobuf_Unittest_TestCamelCaseFieldNames._fromBuilder(Protobuf_Unittest_TestCamelCaseFieldNames_Builder b) : super(b);
+  Protobuf_Unittest_TestCamelCaseFieldNames_Builder toBuilder() => newBuilder().mergeFromMessage(this);
+
+  // optional int32 PrimitiveField = 1;
+  int get primitivefield() => g_(1);
+  bool hasPrimitivefield() => h_(1);
+
+  // optional string StringField = 2;
+  String get stringfield() => g_(2);
+  bool hasStringfield() => h_(2);
+
+  // optional enum EnumField = 3;
+  Protobuf_Unittest_ForeignEnum get enumfield() => g_(3);
+  bool hasEnumfield() => h_(3);
+
+  // optional protobuf_unittest.ForeignMessage MessageField = 4;
+  Protobuf_Unittest_ForeignMessage get messagefield() => g_(4);
+  bool hasMessagefield() => h_(4);
+
+  // optional string StringPieceField = 5;
+  String get stringpiecefield() => g_(5);
+  bool hasStringpiecefield() => h_(5);
+
+  // optional string CordField = 6;
+  String get cordfield() => g_(6);
+  bool hasCordfield() => h_(6);
+
+  // repeated int32 RepeatedPrimitiveField = 7;
+  List<int> get repeatedprimitivefield() => g_(7);
+
+  // repeated string RepeatedStringField = 8;
+  List<String> get repeatedstringfield() => g_(8);
+
+  // repeated enum RepeatedEnumField = 9;
+  List<Protobuf_Unittest_ForeignEnum> get repeatedenumfield() => g_(9);
+
+  // repeated protobuf_unittest.ForeignMessage RepeatedMessageField = 10;
+  List<Protobuf_Unittest_ForeignMessage> get repeatedmessagefield() => g_(10);
+
+  // repeated string RepeatedStringPieceField = 11;
+  List<String> get repeatedstringpiecefield() => g_(11);
+
+  // repeated string RepeatedCordField = 12;
+  List<String> get repeatedcordfield() => g_(12);
+}
+
+class Protobuf_Unittest_TestCamelCaseFieldNames_Builder extends Builder {
+  static BuilderInfo _i;
+
+  void initialize_() {
+    if (null == _i) {
+      _i = new BuilderInfo(this, "Protobuf_Unittest_TestCamelCaseFieldNames");
+      _i.a(1, 'primitivefield', Builder.O3);
+      _i.a(2, 'stringfield', Builder.OS);
+      _i.e(3, 'enumfield', Builder.OE, () => Protobuf_Unittest_ForeignEnum.FOREIGN_FOO, (var v) => Protobuf_Unittest_ForeignEnum.valueOf(v));
+      _i.a(4, 'messagefield', Builder.OM, () => Protobuf_Unittest_ForeignMessage.defaultInstance, () => new Protobuf_Unittest_ForeignMessage_Builder());
+      _i.a(5, 'stringpiecefield', Builder.OS);
+      _i.a(6, 'cordfield', Builder.OS);
+      _i.p(7, 'repeatedprimitivefield', Builder.P3);
+      _i.p(8, 'repeatedstringfield', Builder.PS);
+      _i.a(9, 'repeatedenumfield', Builder.PE, () => new PbList(this), null, (var v) => Protobuf_Unittest_ForeignEnum.valueOf(v));
+      _i.m(10, 'repeatedmessagefield', () => new Protobuf_Unittest_ForeignMessage_Builder(), () => new PbList<Protobuf_Unittest_ForeignMessage>(this));
+      _i.p(11, 'repeatedstringpiecefield', Builder.PS);
+      _i.p(12, 'repeatedcordfield', Builder.PS);
+      _i.hasRequiredFields = false;
+    }
+  }
+
+  Protobuf_Unittest_TestCamelCaseFieldNames build() => super.build();
+  Protobuf_Unittest_TestCamelCaseFieldNames buildPartial() => partial(new Protobuf_Unittest_TestCamelCaseFieldNames._fromBuilder(this));
+  BuilderInfo get info_() => _i;
+
+  int get primitivefield() => g_(1);
+  void set primitivefield(int v) { s_(1, v); }
+  bool hasPrimitivefield() => h_(1);
+  void clearPrimitivefield() => c_(1);
+
+  String get stringfield() => g_(2);
+  void set stringfield(String v) { s_(2, v); }
+  bool hasStringfield() => h_(2);
+  void clearStringfield() => c_(2);
+
+  Protobuf_Unittest_ForeignEnum get enumfield() => g_(3);
+  void set enumfield(Protobuf_Unittest_ForeignEnum v) { s_(3, v); }
+  bool hasEnumfield() => h_(3);
+  void clearEnumfield() => c_(3);
+
+  Protobuf_Unittest_ForeignMessage get messagefield() => g_(4);
+  void set messagefield(Protobuf_Unittest_ForeignMessage v) { s_(4, v); }
+  bool hasMessagefield() => h_(4);
+  void clearMessagefield() => c_(4);
+
+  String get stringpiecefield() => g_(5);
+  void set stringpiecefield(String v) { s_(5, v); }
+  bool hasStringpiecefield() => h_(5);
+  void clearStringpiecefield() => c_(5);
+
+  String get cordfield() => g_(6);
+  void set cordfield(String v) { s_(6, v); }
+  bool hasCordfield() => h_(6);
+  void clearCordfield() => c_(6);
+
+  List<int> get repeatedprimitivefield() => g_(7);
+
+  List<String> get repeatedstringfield() => g_(8);
+
+  List<Protobuf_Unittest_ForeignEnum> get repeatedenumfield() => g_(9);
+
+  List<Protobuf_Unittest_ForeignMessage> get repeatedmessagefield() => g_(10);
+
+  List<String> get repeatedstringpiecefield() => g_(11);
+
+  List<String> get repeatedcordfield() => g_(12);
+}
+
+class Protobuf_Unittest_TestFieldOrderings extends GeneratedMessage {
+  static Protobuf_Unittest_TestFieldOrderings _d;
+  static Protobuf_Unittest_TestFieldOrderings_Builder newBuilder() => new Protobuf_Unittest_TestFieldOrderings_Builder();
+  static Protobuf_Unittest_TestFieldOrderings get defaultInstance() => null == _d ? (_d = newBuilder().buildPartial()) : _d;
+  static Protobuf_Unittest_TestFieldOrderings parseFromBuffer(List<int> i, [ExtensionRegistry r]) => GeneratedMessage.parseBuffer(newBuilder(), i, r);
+  static Future<Protobuf_Unittest_TestFieldOrderings> parseFromStream(InputStream i, [ExtensionRegistry r]) => GeneratedMessage.parseStream(newBuilder(), i, r);
+  static Protobuf_Unittest_TestFieldOrderings parseFromJson(String i, [ExtensionRegistry r]) => GeneratedMessage.parseJson(newBuilder(), i, r);
+  Protobuf_Unittest_TestFieldOrderings._fromBuilder(Protobuf_Unittest_TestFieldOrderings_Builder b) : super(b);
+  Protobuf_Unittest_TestFieldOrderings_Builder toBuilder() => newBuilder().mergeFromMessage(this);
+
+  // optional string my_string = 11;
+  String get myString() => g_(11);
+  bool hasMyString() => h_(11);
+
+  // optional int64 my_int = 1;
+  int get myInt() => g_(1);
+  bool hasMyInt() => h_(1);
+
+  // optional float my_float = 101;
+  double get myFloat() => g_(101);
+  bool hasMyFloat() => h_(101);
+}
+
+class Protobuf_Unittest_TestFieldOrderings_Builder extends Builder {
+  static BuilderInfo _i;
+
+  void initialize_() {
+    if (null == _i) {
+      _i = new BuilderInfo(this, "Protobuf_Unittest_TestFieldOrderings");
+      _i.a(11, 'myString', Builder.OS);
+      _i.a(1, 'myInt', Builder.O6);
+      _i.a(101, 'myFloat', Builder.OF);
+      _i.hasExtensions = true;
+    }
+  }
+
+  Protobuf_Unittest_TestFieldOrderings build() => super.build();
+  Protobuf_Unittest_TestFieldOrderings buildPartial() => partial(new Protobuf_Unittest_TestFieldOrderings._fromBuilder(this));
+  BuilderInfo get info_() => _i;
+
+  String get myString() => g_(11);
+  void set myString(String v) { s_(11, v); }
+  bool hasMyString() => h_(11);
+  void clearMyString() => c_(11);
+
+  int get myInt() => g_(1);
+  void set myInt(int v) { s_(1, v); }
+  bool hasMyInt() => h_(1);
+  void clearMyInt() => c_(1);
+
+  double get myFloat() => g_(101);
+  void set myFloat(double v) { s_(101, v); }
+  bool hasMyFloat() => h_(101);
+  void clearMyFloat() => c_(101);
+}
+
+class Protobuf_Unittest_TestExtremeDefaultValues extends GeneratedMessage {
+  static Protobuf_Unittest_TestExtremeDefaultValues _d;
+  static Protobuf_Unittest_TestExtremeDefaultValues_Builder newBuilder() => new Protobuf_Unittest_TestExtremeDefaultValues_Builder();
+  static Protobuf_Unittest_TestExtremeDefaultValues get defaultInstance() => null == _d ? (_d = newBuilder().buildPartial()) : _d;
+  static Protobuf_Unittest_TestExtremeDefaultValues parseFromBuffer(List<int> i, [ExtensionRegistry r]) => GeneratedMessage.parseBuffer(newBuilder(), i, r);
+  static Future<Protobuf_Unittest_TestExtremeDefaultValues> parseFromStream(InputStream i, [ExtensionRegistry r]) => GeneratedMessage.parseStream(newBuilder(), i, r);
+  static Protobuf_Unittest_TestExtremeDefaultValues parseFromJson(String i, [ExtensionRegistry r]) => GeneratedMessage.parseJson(newBuilder(), i, r);
+  Protobuf_Unittest_TestExtremeDefaultValues._fromBuilder(Protobuf_Unittest_TestExtremeDefaultValues_Builder b) : super(b);
+  Protobuf_Unittest_TestExtremeDefaultValues_Builder toBuilder() => newBuilder().mergeFromMessage(this);
+
+  // optional bytes escaped_bytes = 1;
+  List<int> get escapedBytes() => g_(1);
+  bool hasEscapedBytes() => h_(1);
+
+  // optional uint32 large_uint32 = 2;
+  int get largeUint32() => g_(2);
+  bool hasLargeUint32() => h_(2);
+
+  // optional uint64 large_uint64 = 3;
+  int get largeUint64() => g_(3);
+  bool hasLargeUint64() => h_(3);
+
+  // optional int32 small_int32 = 4;
+  int get smallInt32() => g_(4);
+  bool hasSmallInt32() => h_(4);
+
+  // optional int64 small_int64 = 5;
+  int get smallInt64() => g_(5);
+  bool hasSmallInt64() => h_(5);
+
+  // optional string utf8_string = 6;
+  String get utf8String() => g_(6);
+  bool hasUtf8String() => h_(6);
+
+  // optional float zero_float = 7;
+  double get zeroFloat() => g_(7);
+  bool hasZeroFloat() => h_(7);
+
+  // optional float one_float = 8;
+  double get oneFloat() => g_(8);
+  bool hasOneFloat() => h_(8);
+
+  // optional float small_float = 9;
+  double get smallFloat() => g_(9);
+  bool hasSmallFloat() => h_(9);
+
+  // optional float negative_one_float = 10;
+  double get negativeOneFloat() => g_(10);
+  bool hasNegativeOneFloat() => h_(10);
+
+  // optional float negative_float = 11;
+  double get negativeFloat() => g_(11);
+  bool hasNegativeFloat() => h_(11);
+
+  // optional float large_float = 12;
+  double get largeFloat() => g_(12);
+  bool hasLargeFloat() => h_(12);
+
+  // optional float small_negative_float = 13;
+  double get smallNegativeFloat() => g_(13);
+  bool hasSmallNegativeFloat() => h_(13);
+
+  // optional double inf_double = 14;
+  double get infDouble() => g_(14);
+  bool hasInfDouble() => h_(14);
+
+  // optional double neg_inf_double = 15;
+  double get negInfDouble() => g_(15);
+  bool hasNegInfDouble() => h_(15);
+
+  // optional double nan_double = 16;
+  double get nanDouble() => g_(16);
+  bool hasNanDouble() => h_(16);
+
+  // optional float inf_float = 17;
+  double get infFloat() => g_(17);
+  bool hasInfFloat() => h_(17);
+
+  // optional float neg_inf_float = 18;
+  double get negInfFloat() => g_(18);
+  bool hasNegInfFloat() => h_(18);
+
+  // optional float nan_float = 19;
+  double get nanFloat() => g_(19);
+  bool hasNanFloat() => h_(19);
+
+  // optional string cpp_trigraph = 20;
+  String get cppTrigraph() => g_(20);
+  bool hasCppTrigraph() => h_(20);
+}
+
+class Protobuf_Unittest_TestExtremeDefaultValues_Builder extends Builder {
+  static BuilderInfo _i;
+
+  void initialize_() {
+    if (null == _i) {
+      _i = new BuilderInfo(this, "Protobuf_Unittest_TestExtremeDefaultValues");
+      _i.a(1, 'escapedBytes', Builder.OY, () => <int>[0x5c,0x30,0x30,0x30,0x5c,0x30,0x30,0x31,0x5c,0x30,0x30,0x37,0x5c,0x30,0x31,0x30,0x5c,0x30,0x31,0x34,0x5c,0x6e,0x5c,0x72,0x5c,0x74,0x5c,0x30,0x31,0x33,0x5c,0x5c,0x5c,0x27,0x5c,0x22,0x5c,0x33,0x37,0x36]);
+      _i.a(2, 'largeUint32', Builder.OU3, () => 4294967295);
+      _i.a(3, 'largeUint64', Builder.OU6, () => 18446744073709551615);
+      _i.a(4, 'smallInt32', Builder.O3, () => -2147483647);
+      _i.a(5, 'smallInt64', Builder.O6, () => -9223372036854775807);
+      _i.a(6, 'utf8String', Builder.OS, () => 'ሴ');
+      _i.a(7, 'zeroFloat', Builder.OF, () => 0.0);
+      _i.a(8, 'oneFloat', Builder.OF, () => 1.0);
+      _i.a(9, 'smallFloat', Builder.OF, () => 1.5);
+      _i.a(10, 'negativeOneFloat', Builder.OF, () => -1.0);
+      _i.a(11, 'negativeFloat', Builder.OF, () => -1.5);
+      _i.a(12, 'largeFloat', Builder.OF, () => 2e+08);
+      _i.a(13, 'smallNegativeFloat', Builder.OF, () => -8e-28);
+      _i.a(14, 'infDouble', Builder.OD, () => double.INFINITY);
+      _i.a(15, 'negInfDouble', Builder.OD, () => double.NEGATIVE_INFINITY);
+      _i.a(16, 'nanDouble', Builder.OD, () => double.NAN);
+      _i.a(17, 'infFloat', Builder.OF, () => double.INFINITY);
+      _i.a(18, 'negInfFloat', Builder.OF, () => double.NEGATIVE_INFINITY);
+      _i.a(19, 'nanFloat', Builder.OF, () => double.NAN);
+      _i.a(20, 'cppTrigraph', Builder.OS, () => '? ? ?? ?? ??? ??/ ??-');
+      _i.hasRequiredFields = false;
+    }
+  }
+
+  Protobuf_Unittest_TestExtremeDefaultValues build() => super.build();
+  Protobuf_Unittest_TestExtremeDefaultValues buildPartial() => partial(new Protobuf_Unittest_TestExtremeDefaultValues._fromBuilder(this));
+  BuilderInfo get info_() => _i;
+
+  List<int> get escapedBytes() => g_(1);
+  void set escapedBytes(List<int> v) { s_(1, v); }
+  bool hasEscapedBytes() => h_(1);
+  void clearEscapedBytes() => c_(1);
+
+  int get largeUint32() => g_(2);
+  void set largeUint32(int v) { s_(2, v); }
+  bool hasLargeUint32() => h_(2);
+  void clearLargeUint32() => c_(2);
+
+  int get largeUint64() => g_(3);
+  void set largeUint64(int v) { s_(3, v); }
+  bool hasLargeUint64() => h_(3);
+  void clearLargeUint64() => c_(3);
+
+  int get smallInt32() => g_(4);
+  void set smallInt32(int v) { s_(4, v); }
+  bool hasSmallInt32() => h_(4);
+  void clearSmallInt32() => c_(4);
+
+  int get smallInt64() => g_(5);
+  void set smallInt64(int v) { s_(5, v); }
+  bool hasSmallInt64() => h_(5);
+  void clearSmallInt64() => c_(5);
+
+  String get utf8String() => g_(6);
+  void set utf8String(String v) { s_(6, v); }
+  bool hasUtf8String() => h_(6);
+  void clearUtf8String() => c_(6);
+
+  double get zeroFloat() => g_(7);
+  void set zeroFloat(double v) { s_(7, v); }
+  bool hasZeroFloat() => h_(7);
+  void clearZeroFloat() => c_(7);
+
+  double get oneFloat() => g_(8);
+  void set oneFloat(double v) { s_(8, v); }
+  bool hasOneFloat() => h_(8);
+  void clearOneFloat() => c_(8);
+
+  double get smallFloat() => g_(9);
+  void set smallFloat(double v) { s_(9, v); }
+  bool hasSmallFloat() => h_(9);
+  void clearSmallFloat() => c_(9);
+
+  double get negativeOneFloat() => g_(10);
+  void set negativeOneFloat(double v) { s_(10, v); }
+  bool hasNegativeOneFloat() => h_(10);
+  void clearNegativeOneFloat() => c_(10);
+
+  double get negativeFloat() => g_(11);
+  void set negativeFloat(double v) { s_(11, v); }
+  bool hasNegativeFloat() => h_(11);
+  void clearNegativeFloat() => c_(11);
+
+  double get largeFloat() => g_(12);
+  void set largeFloat(double v) { s_(12, v); }
+  bool hasLargeFloat() => h_(12);
+  void clearLargeFloat() => c_(12);
+
+  double get smallNegativeFloat() => g_(13);
+  void set smallNegativeFloat(double v) { s_(13, v); }
+  bool hasSmallNegativeFloat() => h_(13);
+  void clearSmallNegativeFloat() => c_(13);
+
+  double get infDouble() => g_(14);
+  void set infDouble(double v) { s_(14, v); }
+  bool hasInfDouble() => h_(14);
+  void clearInfDouble() => c_(14);
+
+  double get negInfDouble() => g_(15);
+  void set negInfDouble(double v) { s_(15, v); }
+  bool hasNegInfDouble() => h_(15);
+  void clearNegInfDouble() => c_(15);
+
+  double get nanDouble() => g_(16);
+  void set nanDouble(double v) { s_(16, v); }
+  bool hasNanDouble() => h_(16);
+  void clearNanDouble() => c_(16);
+
+  double get infFloat() => g_(17);
+  void set infFloat(double v) { s_(17, v); }
+  bool hasInfFloat() => h_(17);
+  void clearInfFloat() => c_(17);
+
+  double get negInfFloat() => g_(18);
+  void set negInfFloat(double v) { s_(18, v); }
+  bool hasNegInfFloat() => h_(18);
+  void clearNegInfFloat() => c_(18);
+
+  double get nanFloat() => g_(19);
+  void set nanFloat(double v) { s_(19, v); }
+  bool hasNanFloat() => h_(19);
+  void clearNanFloat() => c_(19);
+
+  String get cppTrigraph() => g_(20);
+  void set cppTrigraph(String v) { s_(20, v); }
+  bool hasCppTrigraph() => h_(20);
+  void clearCppTrigraph() => c_(20);
+}
+
+class Protobuf_Unittest_SparseEnumMessage extends GeneratedMessage {
+  static Protobuf_Unittest_SparseEnumMessage _d;
+  static Protobuf_Unittest_SparseEnumMessage_Builder newBuilder() => new Protobuf_Unittest_SparseEnumMessage_Builder();
+  static Protobuf_Unittest_SparseEnumMessage get defaultInstance() => null == _d ? (_d = newBuilder().buildPartial()) : _d;
+  static Protobuf_Unittest_SparseEnumMessage parseFromBuffer(List<int> i, [ExtensionRegistry r]) => GeneratedMessage.parseBuffer(newBuilder(), i, r);
+  static Future<Protobuf_Unittest_SparseEnumMessage> parseFromStream(InputStream i, [ExtensionRegistry r]) => GeneratedMessage.parseStream(newBuilder(), i, r);
+  static Protobuf_Unittest_SparseEnumMessage parseFromJson(String i, [ExtensionRegistry r]) => GeneratedMessage.parseJson(newBuilder(), i, r);
+  Protobuf_Unittest_SparseEnumMessage._fromBuilder(Protobuf_Unittest_SparseEnumMessage_Builder b) : super(b);
+  Protobuf_Unittest_SparseEnumMessage_Builder toBuilder() => newBuilder().mergeFromMessage(this);
+
+  // optional enum sparse_enum = 1;
+  Protobuf_Unittest_TestSparseEnum get sparseEnum() => g_(1);
+  bool hasSparseEnum() => h_(1);
+}
+
+class Protobuf_Unittest_SparseEnumMessage_Builder extends Builder {
+  static BuilderInfo _i;
+
+  void initialize_() {
+    if (null == _i) {
+      _i = new BuilderInfo(this, "Protobuf_Unittest_SparseEnumMessage");
+      _i.e(1, 'sparseEnum', Builder.OE, () => Protobuf_Unittest_TestSparseEnum.SPARSE_A, (var v) => Protobuf_Unittest_TestSparseEnum.valueOf(v));
+      _i.hasRequiredFields = false;
+    }
+  }
+
+  Protobuf_Unittest_SparseEnumMessage build() => super.build();
+  Protobuf_Unittest_SparseEnumMessage buildPartial() => partial(new Protobuf_Unittest_SparseEnumMessage._fromBuilder(this));
+  BuilderInfo get info_() => _i;
+
+  Protobuf_Unittest_TestSparseEnum get sparseEnum() => g_(1);
+  void set sparseEnum(Protobuf_Unittest_TestSparseEnum v) { s_(1, v); }
+  bool hasSparseEnum() => h_(1);
+  void clearSparseEnum() => c_(1);
+}
+
+class Protobuf_Unittest_OneString extends GeneratedMessage {
+  static Protobuf_Unittest_OneString _d;
+  static Protobuf_Unittest_OneString_Builder newBuilder() => new Protobuf_Unittest_OneString_Builder();
+  static Protobuf_Unittest_OneString get defaultInstance() => null == _d ? (_d = newBuilder().buildPartial()) : _d;
+  static Protobuf_Unittest_OneString parseFromBuffer(List<int> i, [ExtensionRegistry r]) => GeneratedMessage.parseBuffer(newBuilder(), i, r);
+  static Future<Protobuf_Unittest_OneString> parseFromStream(InputStream i, [ExtensionRegistry r]) => GeneratedMessage.parseStream(newBuilder(), i, r);
+  static Protobuf_Unittest_OneString parseFromJson(String i, [ExtensionRegistry r]) => GeneratedMessage.parseJson(newBuilder(), i, r);
+  Protobuf_Unittest_OneString._fromBuilder(Protobuf_Unittest_OneString_Builder b) : super(b);
+  Protobuf_Unittest_OneString_Builder toBuilder() => newBuilder().mergeFromMessage(this);
+
+  // optional string data = 1;
+  String get data() => g_(1);
+  bool hasData() => h_(1);
+}
+
+class Protobuf_Unittest_OneString_Builder extends Builder {
+  static BuilderInfo _i;
+
+  void initialize_() {
+    if (null == _i) {
+      _i = new BuilderInfo(this, "Protobuf_Unittest_OneString");
+      _i.a(1, 'data', Builder.OS);
+      _i.hasRequiredFields = false;
+    }
+  }
+
+  Protobuf_Unittest_OneString build() => super.build();
+  Protobuf_Unittest_OneString buildPartial() => partial(new Protobuf_Unittest_OneString._fromBuilder(this));
+  BuilderInfo get info_() => _i;
+
+  String get data() => g_(1);
+  void set data(String v) { s_(1, v); }
+  bool hasData() => h_(1);
+  void clearData() => c_(1);
+}
+
+class Protobuf_Unittest_OneBytes extends GeneratedMessage {
+  static Protobuf_Unittest_OneBytes _d;
+  static Protobuf_Unittest_OneBytes_Builder newBuilder() => new Protobuf_Unittest_OneBytes_Builder();
+  static Protobuf_Unittest_OneBytes get defaultInstance() => null == _d ? (_d = newBuilder().buildPartial()) : _d;
+  static Protobuf_Unittest_OneBytes parseFromBuffer(List<int> i, [ExtensionRegistry r]) => GeneratedMessage.parseBuffer(newBuilder(), i, r);
+  static Future<Protobuf_Unittest_OneBytes> parseFromStream(InputStream i, [ExtensionRegistry r]) => GeneratedMessage.parseStream(newBuilder(), i, r);
+  static Protobuf_Unittest_OneBytes parseFromJson(String i, [ExtensionRegistry r]) => GeneratedMessage.parseJson(newBuilder(), i, r);
+  Protobuf_Unittest_OneBytes._fromBuilder(Protobuf_Unittest_OneBytes_Builder b) : super(b);
+  Protobuf_Unittest_OneBytes_Builder toBuilder() => newBuilder().mergeFromMessage(this);
+
+  // optional bytes data = 1;
+  List<int> get data() => g_(1);
+  bool hasData() => h_(1);
+}
+
+class Protobuf_Unittest_OneBytes_Builder extends Builder {
+  static BuilderInfo _i;
+
+  void initialize_() {
+    if (null == _i) {
+      _i = new BuilderInfo(this, "Protobuf_Unittest_OneBytes");
+      _i.a(1, 'data', Builder.OY);
+      _i.hasRequiredFields = false;
+    }
+  }
+
+  Protobuf_Unittest_OneBytes build() => super.build();
+  Protobuf_Unittest_OneBytes buildPartial() => partial(new Protobuf_Unittest_OneBytes._fromBuilder(this));
+  BuilderInfo get info_() => _i;
+
+  List<int> get data() => g_(1);
+  void set data(List<int> v) { s_(1, v); }
+  bool hasData() => h_(1);
+  void clearData() => c_(1);
+}
+
+class Protobuf_Unittest_TestPackedTypes extends GeneratedMessage {
+  static Protobuf_Unittest_TestPackedTypes _d;
+  static Protobuf_Unittest_TestPackedTypes_Builder newBuilder() => new Protobuf_Unittest_TestPackedTypes_Builder();
+  static Protobuf_Unittest_TestPackedTypes get defaultInstance() => null == _d ? (_d = newBuilder().buildPartial()) : _d;
+  static Protobuf_Unittest_TestPackedTypes parseFromBuffer(List<int> i, [ExtensionRegistry r]) => GeneratedMessage.parseBuffer(newBuilder(), i, r);
+  static Future<Protobuf_Unittest_TestPackedTypes> parseFromStream(InputStream i, [ExtensionRegistry r]) => GeneratedMessage.parseStream(newBuilder(), i, r);
+  static Protobuf_Unittest_TestPackedTypes parseFromJson(String i, [ExtensionRegistry r]) => GeneratedMessage.parseJson(newBuilder(), i, r);
+  Protobuf_Unittest_TestPackedTypes._fromBuilder(Protobuf_Unittest_TestPackedTypes_Builder b) : super(b);
+  Protobuf_Unittest_TestPackedTypes_Builder toBuilder() => newBuilder().mergeFromMessage(this);
+
+  // repeated int32 packed_int32 = 90 [packed=true];
+  List<int> get packedInt32() => g_(90);
+
+  // repeated int64 packed_int64 = 91 [packed=true];
+  List<int> get packedInt64() => g_(91);
+
+  // repeated uint32 packed_uint32 = 92 [packed=true];
+  List<int> get packedUint32() => g_(92);
+
+  // repeated uint64 packed_uint64 = 93 [packed=true];
+  List<int> get packedUint64() => g_(93);
+
+  // repeated sint32 packed_sint32 = 94 [packed=true];
+  List<int> get packedSint32() => g_(94);
+
+  // repeated sint64 packed_sint64 = 95 [packed=true];
+  List<int> get packedSint64() => g_(95);
+
+  // repeated fixed32 packed_fixed32 = 96 [packed=true];
+  List<int> get packedFixed32() => g_(96);
+
+  // repeated fixed64 packed_fixed64 = 97 [packed=true];
+  List<int> get packedFixed64() => g_(97);
+
+  // repeated sfixed32 packed_sfixed32 = 98 [packed=true];
+  List<int> get packedSfixed32() => g_(98);
+
+  // repeated sfixed64 packed_sfixed64 = 99 [packed=true];
+  List<int> get packedSfixed64() => g_(99);
+
+  // repeated float packed_float = 100 [packed=true];
+  List<double> get packedFloat() => g_(100);
+
+  // repeated double packed_double = 101 [packed=true];
+  List<double> get packedDouble() => g_(101);
+
+  // repeated bool packed_bool = 102 [packed=true];
+  List<bool> get packedBool() => g_(102);
+
+  // repeated enum packed_enum = 103 [packed=true];
+  List<Protobuf_Unittest_ForeignEnum> get packedEnum() => g_(103);
+}
+
+class Protobuf_Unittest_TestPackedTypes_Builder extends Builder {
+  static BuilderInfo _i;
+
+  void initialize_() {
+    if (null == _i) {
+      _i = new BuilderInfo(this, "Protobuf_Unittest_TestPackedTypes");
+      _i.a(90, 'packedInt32', Builder.K3, () => new PbList(this));
+      _i.a(91, 'packedInt64', Builder.K6, () => new PbList(this));
+      _i.a(92, 'packedUint32', Builder.KU3, () => new PbList(this));
+      _i.a(93, 'packedUint64', Builder.KU6, () => new PbList(this));
+      _i.a(94, 'packedSint32', Builder.KS3, () => new PbList(this));
+      _i.a(95, 'packedSint64', Builder.KS6, () => new PbList(this));
+      _i.a(96, 'packedFixed32', Builder.KF3, () => new PbList(this));
+      _i.a(97, 'packedFixed64', Builder.KF6, () => new PbList(this));
+      _i.a(98, 'packedSfixed32', Builder.KSF3, () => new PbList(this));
+      _i.a(99, 'packedSfixed64', Builder.KSF6, () => new PbList(this));
+      _i.a(100, 'packedFloat', Builder.KF, () => new PbList(this));
+      _i.a(101, 'packedDouble', Builder.KD, () => new PbList(this));
+      _i.a(102, 'packedBool', Builder.KB, () => new PbList(this));
+      _i.a(103, 'packedEnum', Builder.KE, () => new PbList(this), null, (var v) => Protobuf_Unittest_ForeignEnum.valueOf(v));
+      _i.hasRequiredFields = false;
+    }
+  }
+
+  Protobuf_Unittest_TestPackedTypes build() => super.build();
+  Protobuf_Unittest_TestPackedTypes buildPartial() => partial(new Protobuf_Unittest_TestPackedTypes._fromBuilder(this));
+  BuilderInfo get info_() => _i;
+
+  List<int> get packedInt32() => g_(90);
+
+  List<int> get packedInt64() => g_(91);
+
+  List<int> get packedUint32() => g_(92);
+
+  List<int> get packedUint64() => g_(93);
+
+  List<int> get packedSint32() => g_(94);
+
+  List<int> get packedSint64() => g_(95);
+
+  List<int> get packedFixed32() => g_(96);
+
+  List<int> get packedFixed64() => g_(97);
+
+  List<int> get packedSfixed32() => g_(98);
+
+  List<int> get packedSfixed64() => g_(99);
+
+  List<double> get packedFloat() => g_(100);
+
+  List<double> get packedDouble() => g_(101);
+
+  List<bool> get packedBool() => g_(102);
+
+  List<Protobuf_Unittest_ForeignEnum> get packedEnum() => g_(103);
+}
+
+class Protobuf_Unittest_TestUnpackedTypes extends GeneratedMessage {
+  static Protobuf_Unittest_TestUnpackedTypes _d;
+  static Protobuf_Unittest_TestUnpackedTypes_Builder newBuilder() => new Protobuf_Unittest_TestUnpackedTypes_Builder();
+  static Protobuf_Unittest_TestUnpackedTypes get defaultInstance() => null == _d ? (_d = newBuilder().buildPartial()) : _d;
+  static Protobuf_Unittest_TestUnpackedTypes parseFromBuffer(List<int> i, [ExtensionRegistry r]) => GeneratedMessage.parseBuffer(newBuilder(), i, r);
+  static Future<Protobuf_Unittest_TestUnpackedTypes> parseFromStream(InputStream i, [ExtensionRegistry r]) => GeneratedMessage.parseStream(newBuilder(), i, r);
+  static Protobuf_Unittest_TestUnpackedTypes parseFromJson(String i, [ExtensionRegistry r]) => GeneratedMessage.parseJson(newBuilder(), i, r);
+  Protobuf_Unittest_TestUnpackedTypes._fromBuilder(Protobuf_Unittest_TestUnpackedTypes_Builder b) : super(b);
+  Protobuf_Unittest_TestUnpackedTypes_Builder toBuilder() => newBuilder().mergeFromMessage(this);
+
+  // repeated int32 unpacked_int32 = 90;
+  List<int> get unpackedInt32() => g_(90);
+
+  // repeated int64 unpacked_int64 = 91;
+  List<int> get unpackedInt64() => g_(91);
+
+  // repeated uint32 unpacked_uint32 = 92;
+  List<int> get unpackedUint32() => g_(92);
+
+  // repeated uint64 unpacked_uint64 = 93;
+  List<int> get unpackedUint64() => g_(93);
+
+  // repeated sint32 unpacked_sint32 = 94;
+  List<int> get unpackedSint32() => g_(94);
+
+  // repeated sint64 unpacked_sint64 = 95;
+  List<int> get unpackedSint64() => g_(95);
+
+  // repeated fixed32 unpacked_fixed32 = 96;
+  List<int> get unpackedFixed32() => g_(96);
+
+  // repeated fixed64 unpacked_fixed64 = 97;
+  List<int> get unpackedFixed64() => g_(97);
+
+  // repeated sfixed32 unpacked_sfixed32 = 98;
+  List<int> get unpackedSfixed32() => g_(98);
+
+  // repeated sfixed64 unpacked_sfixed64 = 99;
+  List<int> get unpackedSfixed64() => g_(99);
+
+  // repeated float unpacked_float = 100;
+  List<double> get unpackedFloat() => g_(100);
+
+  // repeated double unpacked_double = 101;
+  List<double> get unpackedDouble() => g_(101);
+
+  // repeated bool unpacked_bool = 102;
+  List<bool> get unpackedBool() => g_(102);
+
+  // repeated enum unpacked_enum = 103;
+  List<Protobuf_Unittest_ForeignEnum> get unpackedEnum() => g_(103);
+}
+
+class Protobuf_Unittest_TestUnpackedTypes_Builder extends Builder {
+  static BuilderInfo _i;
+
+  void initialize_() {
+    if (null == _i) {
+      _i = new BuilderInfo(this, "Protobuf_Unittest_TestUnpackedTypes");
+      _i.p(90, 'unpackedInt32', Builder.P3);
+      _i.p(91, 'unpackedInt64', Builder.P6);
+      _i.p(92, 'unpackedUint32', Builder.PU3);
+      _i.p(93, 'unpackedUint64', Builder.PU6);
+      _i.p(94, 'unpackedSint32', Builder.PS3);
+      _i.p(95, 'unpackedSint64', Builder.PS6);
+      _i.p(96, 'unpackedFixed32', Builder.PF3);
+      _i.p(97, 'unpackedFixed64', Builder.PF6);
+      _i.p(98, 'unpackedSfixed32', Builder.PSF3);
+      _i.p(99, 'unpackedSfixed64', Builder.PSF6);
+      _i.p(100, 'unpackedFloat', Builder.PF);
+      _i.p(101, 'unpackedDouble', Builder.PD);
+      _i.p(102, 'unpackedBool', Builder.PB);
+      _i.a(103, 'unpackedEnum', Builder.PE, () => new PbList(this), null, (var v) => Protobuf_Unittest_ForeignEnum.valueOf(v));
+      _i.hasRequiredFields = false;
+    }
+  }
+
+  Protobuf_Unittest_TestUnpackedTypes build() => super.build();
+  Protobuf_Unittest_TestUnpackedTypes buildPartial() => partial(new Protobuf_Unittest_TestUnpackedTypes._fromBuilder(this));
+  BuilderInfo get info_() => _i;
+
+  List<int> get unpackedInt32() => g_(90);
+
+  List<int> get unpackedInt64() => g_(91);
+
+  List<int> get unpackedUint32() => g_(92);
+
+  List<int> get unpackedUint64() => g_(93);
+
+  List<int> get unpackedSint32() => g_(94);
+
+  List<int> get unpackedSint64() => g_(95);
+
+  List<int> get unpackedFixed32() => g_(96);
+
+  List<int> get unpackedFixed64() => g_(97);
+
+  List<int> get unpackedSfixed32() => g_(98);
+
+  List<int> get unpackedSfixed64() => g_(99);
+
+  List<double> get unpackedFloat() => g_(100);
+
+  List<double> get unpackedDouble() => g_(101);
+
+  List<bool> get unpackedBool() => g_(102);
+
+  List<Protobuf_Unittest_ForeignEnum> get unpackedEnum() => g_(103);
+}
+
+class Protobuf_Unittest_TestPackedExtensions extends GeneratedMessage {
+  static Protobuf_Unittest_TestPackedExtensions _d;
+  static Protobuf_Unittest_TestPackedExtensions_Builder newBuilder() => new Protobuf_Unittest_TestPackedExtensions_Builder();
+  static Protobuf_Unittest_TestPackedExtensions get defaultInstance() => null == _d ? (_d = newBuilder().buildPartial()) : _d;
+  static Protobuf_Unittest_TestPackedExtensions parseFromBuffer(List<int> i, [ExtensionRegistry r]) => GeneratedMessage.parseBuffer(newBuilder(), i, r);
+  static Future<Protobuf_Unittest_TestPackedExtensions> parseFromStream(InputStream i, [ExtensionRegistry r]) => GeneratedMessage.parseStream(newBuilder(), i, r);
+  static Protobuf_Unittest_TestPackedExtensions parseFromJson(String i, [ExtensionRegistry r]) => GeneratedMessage.parseJson(newBuilder(), i, r);
+  Protobuf_Unittest_TestPackedExtensions._fromBuilder(Protobuf_Unittest_TestPackedExtensions_Builder b) : super(b);
+  Protobuf_Unittest_TestPackedExtensions_Builder toBuilder() => newBuilder().mergeFromMessage(this);
+}
+
+class Protobuf_Unittest_TestPackedExtensions_Builder extends Builder {
+  static BuilderInfo _i;
+
+  void initialize_() {
+    if (null == _i) {
+      _i = new BuilderInfo(this, "Protobuf_Unittest_TestPackedExtensions");
+      _i.hasExtensions = true;
+    }
+  }
+
+  Protobuf_Unittest_TestPackedExtensions build() => super.build();
+  Protobuf_Unittest_TestPackedExtensions buildPartial() => partial(new Protobuf_Unittest_TestPackedExtensions._fromBuilder(this));
+  BuilderInfo get info_() => _i;
+}
+
+class Protobuf_Unittest_TestDynamicExtensions_DynamicEnumType extends ProtobufEnum implements Hashable {
+  static Protobuf_Unittest_TestDynamicExtensions_DynamicEnumType get DYNAMIC_FOO() => values[0];
+  static Protobuf_Unittest_TestDynamicExtensions_DynamicEnumType get DYNAMIC_BAR() => values[1];
+  static Protobuf_Unittest_TestDynamicExtensions_DynamicEnumType get DYNAMIC_BAZ() => values[2];
+  static List<Protobuf_Unittest_TestDynamicExtensions_DynamicEnumType> _byIndex;
+  static Map<int, Protobuf_Unittest_TestDynamicExtensions_DynamicEnumType> _byValue;
+
+  static void _init() {
+    _byIndex = const [
+      const Protobuf_Unittest_TestDynamicExtensions_DynamicEnumType._(0, 2200, 'DYNAMIC_FOO'),
+      const Protobuf_Unittest_TestDynamicExtensions_DynamicEnumType._(1, 2201, 'DYNAMIC_BAR'),
+      const Protobuf_Unittest_TestDynamicExtensions_DynamicEnumType._(2, 2202, 'DYNAMIC_BAZ'),
+    ];
+    _byValue = ProtobufEnum.initByValue(_byIndex);
+  }
+
+  static List<Protobuf_Unittest_TestDynamicExtensions_DynamicEnumType> get values() {
+    if (null == _byIndex) _init();
+    return _byIndex;
+  }
+
+  static Protobuf_Unittest_TestDynamicExtensions_DynamicEnumType valueOf(int value) {
+    if (null == _byValue) _init();
+    return _byValue[value];
+  }
+
+  bool operator ==(Object o) {
+    if (o is Protobuf_Unittest_TestDynamicExtensions_DynamicEnumType) {
+      Protobuf_Unittest_TestDynamicExtensions_DynamicEnumType p = o;
+      return value == p.value;
+    } else {
+      return false;
+    }
+  }
+
+  const Protobuf_Unittest_TestDynamicExtensions_DynamicEnumType._(int i, int v, String n) : super(i, v, n);
+}
+
+class Protobuf_Unittest_TestDynamicExtensions_DynamicMessageType extends GeneratedMessage {
+  static Protobuf_Unittest_TestDynamicExtensions_DynamicMessageType _d;
+  static Protobuf_Unittest_TestDynamicExtensions_DynamicMessageType_Builder newBuilder() => new Protobuf_Unittest_TestDynamicExtensions_DynamicMessageType_Builder();
+  static Protobuf_Unittest_TestDynamicExtensions_DynamicMessageType get defaultInstance() => null == _d ? (_d = newBuilder().buildPartial()) : _d;
+  static Protobuf_Unittest_TestDynamicExtensions_DynamicMessageType parseFromBuffer(List<int> i, [ExtensionRegistry r]) => GeneratedMessage.parseBuffer(newBuilder(), i, r);
+  static Future<Protobuf_Unittest_TestDynamicExtensions_DynamicMessageType> parseFromStream(InputStream i, [ExtensionRegistry r]) => GeneratedMessage.parseStream(newBuilder(), i, r);
+  static Protobuf_Unittest_TestDynamicExtensions_DynamicMessageType parseFromJson(String i, [ExtensionRegistry r]) => GeneratedMessage.parseJson(newBuilder(), i, r);
+  Protobuf_Unittest_TestDynamicExtensions_DynamicMessageType._fromBuilder(Protobuf_Unittest_TestDynamicExtensions_DynamicMessageType_Builder b) : super(b);
+  Protobuf_Unittest_TestDynamicExtensions_DynamicMessageType_Builder toBuilder() => newBuilder().mergeFromMessage(this);
+
+  // optional int32 dynamic_field = 2100;
+  int get dynamicField() => g_(2100);
+  bool hasDynamicField() => h_(2100);
+}
+
+class Protobuf_Unittest_TestDynamicExtensions_DynamicMessageType_Builder extends Builder {
+  static BuilderInfo _i;
+
+  void initialize_() {
+    if (null == _i) {
+      _i = new BuilderInfo(this, "Protobuf_Unittest_TestDynamicExtensions_DynamicMessageType");
+      _i.a(2100, 'dynamicField', Builder.O3);
+      _i.hasRequiredFields = false;
+    }
+  }
+
+  Protobuf_Unittest_TestDynamicExtensions_DynamicMessageType build() => super.build();
+  Protobuf_Unittest_TestDynamicExtensions_DynamicMessageType buildPartial() => partial(new Protobuf_Unittest_TestDynamicExtensions_DynamicMessageType._fromBuilder(this));
+  BuilderInfo get info_() => _i;
+
+  int get dynamicField() => g_(2100);
+  void set dynamicField(int v) { s_(2100, v); }
+  bool hasDynamicField() => h_(2100);
+  void clearDynamicField() => c_(2100);
+}
+
+class Protobuf_Unittest_TestDynamicExtensions extends GeneratedMessage {
+  static Protobuf_Unittest_TestDynamicExtensions _d;
+  static Protobuf_Unittest_TestDynamicExtensions_Builder newBuilder() => new Protobuf_Unittest_TestDynamicExtensions_Builder();
+  static Protobuf_Unittest_TestDynamicExtensions get defaultInstance() => null == _d ? (_d = newBuilder().buildPartial()) : _d;
+  static Protobuf_Unittest_TestDynamicExtensions parseFromBuffer(List<int> i, [ExtensionRegistry r]) => GeneratedMessage.parseBuffer(newBuilder(), i, r);
+  static Future<Protobuf_Unittest_TestDynamicExtensions> parseFromStream(InputStream i, [ExtensionRegistry r]) => GeneratedMessage.parseStream(newBuilder(), i, r);
+  static Protobuf_Unittest_TestDynamicExtensions parseFromJson(String i, [ExtensionRegistry r]) => GeneratedMessage.parseJson(newBuilder(), i, r);
+  Protobuf_Unittest_TestDynamicExtensions._fromBuilder(Protobuf_Unittest_TestDynamicExtensions_Builder b) : super(b);
+  Protobuf_Unittest_TestDynamicExtensions_Builder toBuilder() => newBuilder().mergeFromMessage(this);
+
+  // optional fixed32 scalar_extension = 2000;
+  int get scalarExtension() => g_(2000);
+  bool hasScalarExtension() => h_(2000);
+
+  // optional enum enum_extension = 2001;
+  Protobuf_Unittest_ForeignEnum get enumExtension() => g_(2001);
+  bool hasEnumExtension() => h_(2001);
+
+  // optional enum dynamic_enum_extension = 2002;
+  Protobuf_Unittest_TestDynamicExtensions_DynamicEnumType get dynamicEnumExtension() => g_(2002);
+  bool hasDynamicEnumExtension() => h_(2002);
+
+  // optional protobuf_unittest.ForeignMessage message_extension = 2003;
+  Protobuf_Unittest_ForeignMessage get messageExtension() => g_(2003);
+  bool hasMessageExtension() => h_(2003);
+
+  // optional protobuf_unittest.TestDynamicExtensions.DynamicMessageType dynamic_message_extension = 2004;
+  Protobuf_Unittest_TestDynamicExtensions_DynamicMessageType get dynamicMessageExtension() => g_(2004);
+  bool hasDynamicMessageExtension() => h_(2004);
+
+  // repeated string repeated_extension = 2005;
+  List<String> get repeatedExtension() => g_(2005);
+
+  // repeated sint32 packed_extension = 2006 [packed=true];
+  List<int> get packedExtension() => g_(2006);
+}
+
+class Protobuf_Unittest_TestDynamicExtensions_Builder extends Builder {
+  static BuilderInfo _i;
+
+  void initialize_() {
+    if (null == _i) {
+      _i = new BuilderInfo(this, "Protobuf_Unittest_TestDynamicExtensions");
+      _i.a(2000, 'scalarExtension', Builder.OF3);
+      _i.e(2001, 'enumExtension', Builder.OE, () => Protobuf_Unittest_ForeignEnum.FOREIGN_FOO, (var v) => Protobuf_Unittest_ForeignEnum.valueOf(v));
+      _i.e(2002, 'dynamicEnumExtension', Builder.OE, () => Protobuf_Unittest_TestDynamicExtensions_DynamicEnumType.DYNAMIC_FOO, (var v) => Protobuf_Unittest_TestDynamicExtensions_DynamicEnumType.valueOf(v));
+      _i.a(2003, 'messageExtension', Builder.OM, () => Protobuf_Unittest_ForeignMessage.defaultInstance, () => new Protobuf_Unittest_ForeignMessage_Builder());
+      _i.a(2004, 'dynamicMessageExtension', Builder.OM, () => Protobuf_Unittest_TestDynamicExtensions_DynamicMessageType.defaultInstance, () => new Protobuf_Unittest_TestDynamicExtensions_DynamicMessageType_Builder());
+      _i.p(2005, 'repeatedExtension', Builder.PS);
+      _i.a(2006, 'packedExtension', Builder.KS3, () => new PbList(this));
+      _i.hasRequiredFields = false;
+    }
+  }
+
+  Protobuf_Unittest_TestDynamicExtensions build() => super.build();
+  Protobuf_Unittest_TestDynamicExtensions buildPartial() => partial(new Protobuf_Unittest_TestDynamicExtensions._fromBuilder(this));
+  BuilderInfo get info_() => _i;
+
+  int get scalarExtension() => g_(2000);
+  void set scalarExtension(int v) { s_(2000, v); }
+  bool hasScalarExtension() => h_(2000);
+  void clearScalarExtension() => c_(2000);
+
+  Protobuf_Unittest_ForeignEnum get enumExtension() => g_(2001);
+  void set enumExtension(Protobuf_Unittest_ForeignEnum v) { s_(2001, v); }
+  bool hasEnumExtension() => h_(2001);
+  void clearEnumExtension() => c_(2001);
+
+  Protobuf_Unittest_TestDynamicExtensions_DynamicEnumType get dynamicEnumExtension() => g_(2002);
+  void set dynamicEnumExtension(Protobuf_Unittest_TestDynamicExtensions_DynamicEnumType v) { s_(2002, v); }
+  bool hasDynamicEnumExtension() => h_(2002);
+  void clearDynamicEnumExtension() => c_(2002);
+
+  Protobuf_Unittest_ForeignMessage get messageExtension() => g_(2003);
+  void set messageExtension(Protobuf_Unittest_ForeignMessage v) { s_(2003, v); }
+  bool hasMessageExtension() => h_(2003);
+  void clearMessageExtension() => c_(2003);
+
+  Protobuf_Unittest_TestDynamicExtensions_DynamicMessageType get dynamicMessageExtension() => g_(2004);
+  void set dynamicMessageExtension(Protobuf_Unittest_TestDynamicExtensions_DynamicMessageType v) { s_(2004, v); }
+  bool hasDynamicMessageExtension() => h_(2004);
+  void clearDynamicMessageExtension() => c_(2004);
+
+  List<String> get repeatedExtension() => g_(2005);
+
+  List<int> get packedExtension() => g_(2006);
+}
+
+class Protobuf_Unittest_TestRepeatedScalarDifferentTagSizes extends GeneratedMessage {
+  static Protobuf_Unittest_TestRepeatedScalarDifferentTagSizes _d;
+  static Protobuf_Unittest_TestRepeatedScalarDifferentTagSizes_Builder newBuilder() => new Protobuf_Unittest_TestRepeatedScalarDifferentTagSizes_Builder();
+  static Protobuf_Unittest_TestRepeatedScalarDifferentTagSizes get defaultInstance() => null == _d ? (_d = newBuilder().buildPartial()) : _d;
+  static Protobuf_Unittest_TestRepeatedScalarDifferentTagSizes parseFromBuffer(List<int> i, [ExtensionRegistry r]) => GeneratedMessage.parseBuffer(newBuilder(), i, r);
+  static Future<Protobuf_Unittest_TestRepeatedScalarDifferentTagSizes> parseFromStream(InputStream i, [ExtensionRegistry r]) => GeneratedMessage.parseStream(newBuilder(), i, r);
+  static Protobuf_Unittest_TestRepeatedScalarDifferentTagSizes parseFromJson(String i, [ExtensionRegistry r]) => GeneratedMessage.parseJson(newBuilder(), i, r);
+  Protobuf_Unittest_TestRepeatedScalarDifferentTagSizes._fromBuilder(Protobuf_Unittest_TestRepeatedScalarDifferentTagSizes_Builder b) : super(b);
+  Protobuf_Unittest_TestRepeatedScalarDifferentTagSizes_Builder toBuilder() => newBuilder().mergeFromMessage(this);
+
+  // repeated fixed32 repeated_fixed32 = 12;
+  List<int> get repeatedFixed32() => g_(12);
+
+  // repeated int32 repeated_int32 = 13;
+  List<int> get repeatedInt32() => g_(13);
+
+  // repeated fixed64 repeated_fixed64 = 2046;
+  List<int> get repeatedFixed64() => g_(2046);
+
+  // repeated int64 repeated_int64 = 2047;
+  List<int> get repeatedInt64() => g_(2047);
+
+  // repeated float repeated_float = 262142;
+  List<double> get repeatedFloat() => g_(262142);
+
+  // repeated uint64 repeated_uint64 = 262143;
+  List<int> get repeatedUint64() => g_(262143);
+}
+
+class Protobuf_Unittest_TestRepeatedScalarDifferentTagSizes_Builder extends Builder {
+  static BuilderInfo _i;
+
+  void initialize_() {
+    if (null == _i) {
+      _i = new BuilderInfo(this, "Protobuf_Unittest_TestRepeatedScalarDifferentTagSizes");
+      _i.p(12, 'repeatedFixed32', Builder.PF3);
+      _i.p(13, 'repeatedInt32', Builder.P3);
+      _i.p(2046, 'repeatedFixed64', Builder.PF6);
+      _i.p(2047, 'repeatedInt64', Builder.P6);
+      _i.p(262142, 'repeatedFloat', Builder.PF);
+      _i.p(262143, 'repeatedUint64', Builder.PU6);
+      _i.hasRequiredFields = false;
+    }
+  }
+
+  Protobuf_Unittest_TestRepeatedScalarDifferentTagSizes build() => super.build();
+  Protobuf_Unittest_TestRepeatedScalarDifferentTagSizes buildPartial() => partial(new Protobuf_Unittest_TestRepeatedScalarDifferentTagSizes._fromBuilder(this));
+  BuilderInfo get info_() => _i;
+
+  List<int> get repeatedFixed32() => g_(12);
+
+  List<int> get repeatedInt32() => g_(13);
+
+  List<int> get repeatedFixed64() => g_(2046);
+
+  List<int> get repeatedInt64() => g_(2047);
+
+  List<double> get repeatedFloat() => g_(262142);
+
+  List<int> get repeatedUint64() => g_(262143);
+}
+
+class Protobuf_Unittest_FooRequest extends GeneratedMessage {
+  static Protobuf_Unittest_FooRequest _d;
+  static Protobuf_Unittest_FooRequest_Builder newBuilder() => new Protobuf_Unittest_FooRequest_Builder();
+  static Protobuf_Unittest_FooRequest get defaultInstance() => null == _d ? (_d = newBuilder().buildPartial()) : _d;
+  static Protobuf_Unittest_FooRequest parseFromBuffer(List<int> i, [ExtensionRegistry r]) => GeneratedMessage.parseBuffer(newBuilder(), i, r);
+  static Future<Protobuf_Unittest_FooRequest> parseFromStream(InputStream i, [ExtensionRegistry r]) => GeneratedMessage.parseStream(newBuilder(), i, r);
+  static Protobuf_Unittest_FooRequest parseFromJson(String i, [ExtensionRegistry r]) => GeneratedMessage.parseJson(newBuilder(), i, r);
+  Protobuf_Unittest_FooRequest._fromBuilder(Protobuf_Unittest_FooRequest_Builder b) : super(b);
+  Protobuf_Unittest_FooRequest_Builder toBuilder() => newBuilder().mergeFromMessage(this);
+}
+
+class Protobuf_Unittest_FooRequest_Builder extends Builder {
+  static BuilderInfo _i;
+
+  void initialize_() {
+    if (null == _i) {
+      _i = new BuilderInfo(this, "Protobuf_Unittest_FooRequest");
+      _i.hasRequiredFields = false;
+    }
+  }
+
+  Protobuf_Unittest_FooRequest build() => super.build();
+  Protobuf_Unittest_FooRequest buildPartial() => partial(new Protobuf_Unittest_FooRequest._fromBuilder(this));
+  BuilderInfo get info_() => _i;
+}
+
+class Protobuf_Unittest_FooResponse extends GeneratedMessage {
+  static Protobuf_Unittest_FooResponse _d;
+  static Protobuf_Unittest_FooResponse_Builder newBuilder() => new Protobuf_Unittest_FooResponse_Builder();
+  static Protobuf_Unittest_FooResponse get defaultInstance() => null == _d ? (_d = newBuilder().buildPartial()) : _d;
+  static Protobuf_Unittest_FooResponse parseFromBuffer(List<int> i, [ExtensionRegistry r]) => GeneratedMessage.parseBuffer(newBuilder(), i, r);
+  static Future<Protobuf_Unittest_FooResponse> parseFromStream(InputStream i, [ExtensionRegistry r]) => GeneratedMessage.parseStream(newBuilder(), i, r);
+  static Protobuf_Unittest_FooResponse parseFromJson(String i, [ExtensionRegistry r]) => GeneratedMessage.parseJson(newBuilder(), i, r);
+  Protobuf_Unittest_FooResponse._fromBuilder(Protobuf_Unittest_FooResponse_Builder b) : super(b);
+  Protobuf_Unittest_FooResponse_Builder toBuilder() => newBuilder().mergeFromMessage(this);
+}
+
+class Protobuf_Unittest_FooResponse_Builder extends Builder {
+  static BuilderInfo _i;
+
+  void initialize_() {
+    if (null == _i) {
+      _i = new BuilderInfo(this, "Protobuf_Unittest_FooResponse");
+      _i.hasRequiredFields = false;
+    }
+  }
+
+  Protobuf_Unittest_FooResponse build() => super.build();
+  Protobuf_Unittest_FooResponse buildPartial() => partial(new Protobuf_Unittest_FooResponse._fromBuilder(this));
+  BuilderInfo get info_() => _i;
+}
+
+class Protobuf_Unittest_BarRequest extends GeneratedMessage {
+  static Protobuf_Unittest_BarRequest _d;
+  static Protobuf_Unittest_BarRequest_Builder newBuilder() => new Protobuf_Unittest_BarRequest_Builder();
+  static Protobuf_Unittest_BarRequest get defaultInstance() => null == _d ? (_d = newBuilder().buildPartial()) : _d;
+  static Protobuf_Unittest_BarRequest parseFromBuffer(List<int> i, [ExtensionRegistry r]) => GeneratedMessage.parseBuffer(newBuilder(), i, r);
+  static Future<Protobuf_Unittest_BarRequest> parseFromStream(InputStream i, [ExtensionRegistry r]) => GeneratedMessage.parseStream(newBuilder(), i, r);
+  static Protobuf_Unittest_BarRequest parseFromJson(String i, [ExtensionRegistry r]) => GeneratedMessage.parseJson(newBuilder(), i, r);
+  Protobuf_Unittest_BarRequest._fromBuilder(Protobuf_Unittest_BarRequest_Builder b) : super(b);
+  Protobuf_Unittest_BarRequest_Builder toBuilder() => newBuilder().mergeFromMessage(this);
+}
+
+class Protobuf_Unittest_BarRequest_Builder extends Builder {
+  static BuilderInfo _i;
+
+  void initialize_() {
+    if (null == _i) {
+      _i = new BuilderInfo(this, "Protobuf_Unittest_BarRequest");
+      _i.hasRequiredFields = false;
+    }
+  }
+
+  Protobuf_Unittest_BarRequest build() => super.build();
+  Protobuf_Unittest_BarRequest buildPartial() => partial(new Protobuf_Unittest_BarRequest._fromBuilder(this));
+  BuilderInfo get info_() => _i;
+}
+
+class Protobuf_Unittest_BarResponse extends GeneratedMessage {
+  static Protobuf_Unittest_BarResponse _d;
+  static Protobuf_Unittest_BarResponse_Builder newBuilder() => new Protobuf_Unittest_BarResponse_Builder();
+  static Protobuf_Unittest_BarResponse get defaultInstance() => null == _d ? (_d = newBuilder().buildPartial()) : _d;
+  static Protobuf_Unittest_BarResponse parseFromBuffer(List<int> i, [ExtensionRegistry r]) => GeneratedMessage.parseBuffer(newBuilder(), i, r);
+  static Future<Protobuf_Unittest_BarResponse> parseFromStream(InputStream i, [ExtensionRegistry r]) => GeneratedMessage.parseStream(newBuilder(), i, r);
+  static Protobuf_Unittest_BarResponse parseFromJson(String i, [ExtensionRegistry r]) => GeneratedMessage.parseJson(newBuilder(), i, r);
+  Protobuf_Unittest_BarResponse._fromBuilder(Protobuf_Unittest_BarResponse_Builder b) : super(b);
+  Protobuf_Unittest_BarResponse_Builder toBuilder() => newBuilder().mergeFromMessage(this);
+}
+
+class Protobuf_Unittest_BarResponse_Builder extends Builder {
+  static BuilderInfo _i;
+
+  void initialize_() {
+    if (null == _i) {
+      _i = new BuilderInfo(this, "Protobuf_Unittest_BarResponse");
+      _i.hasRequiredFields = false;
+    }
+  }
+
+  Protobuf_Unittest_BarResponse build() => super.build();
+  Protobuf_Unittest_BarResponse buildPartial() => partial(new Protobuf_Unittest_BarResponse._fromBuilder(this));
+  BuilderInfo get info_() => _i;
+}
+
+class Unittest {
+  static Extension _optionalInt32Extension = null;
+  static Extension get optionalInt32Extension() {
+    if (null == _optionalInt32Extension ) {
+      _optionalInt32Extension = new Extension("Protobuf_Unittest_TestAllExtensions", "optionalInt32Extension", 1, Builder.O3);
+    }
+    return _optionalInt32Extension;
+  }
+  static Extension _optionalInt64Extension = null;
+  static Extension get optionalInt64Extension() {
+    if (null == _optionalInt64Extension ) {
+      _optionalInt64Extension = new Extension("Protobuf_Unittest_TestAllExtensions", "optionalInt64Extension", 2, Builder.O6);
+    }
+    return _optionalInt64Extension;
+  }
+  static Extension _optionalUint32Extension = null;
+  static Extension get optionalUint32Extension() {
+    if (null == _optionalUint32Extension ) {
+      _optionalUint32Extension = new Extension("Protobuf_Unittest_TestAllExtensions", "optionalUint32Extension", 3, Builder.OU3);
+    }
+    return _optionalUint32Extension;
+  }
+  static Extension _optionalUint64Extension = null;
+  static Extension get optionalUint64Extension() {
+    if (null == _optionalUint64Extension ) {
+      _optionalUint64Extension = new Extension("Protobuf_Unittest_TestAllExtensions", "optionalUint64Extension", 4, Builder.OU6);
+    }
+    return _optionalUint64Extension;
+  }
+  static Extension _optionalSint32Extension = null;
+  static Extension get optionalSint32Extension() {
+    if (null == _optionalSint32Extension ) {
+      _optionalSint32Extension = new Extension("Protobuf_Unittest_TestAllExtensions", "optionalSint32Extension", 5, Builder.OS3);
+    }
+    return _optionalSint32Extension;
+  }
+  static Extension _optionalSint64Extension = null;
+  static Extension get optionalSint64Extension() {
+    if (null == _optionalSint64Extension ) {
+      _optionalSint64Extension = new Extension("Protobuf_Unittest_TestAllExtensions", "optionalSint64Extension", 6, Builder.OS6);
+    }
+    return _optionalSint64Extension;
+  }
+  static Extension _optionalFixed32Extension = null;
+  static Extension get optionalFixed32Extension() {
+    if (null == _optionalFixed32Extension ) {
+      _optionalFixed32Extension = new Extension("Protobuf_Unittest_TestAllExtensions", "optionalFixed32Extension", 7, Builder.OF3);
+    }
+    return _optionalFixed32Extension;
+  }
+  static Extension _optionalFixed64Extension = null;
+  static Extension get optionalFixed64Extension() {
+    if (null == _optionalFixed64Extension ) {
+      _optionalFixed64Extension = new Extension("Protobuf_Unittest_TestAllExtensions", "optionalFixed64Extension", 8, Builder.OF6);
+    }
+    return _optionalFixed64Extension;
+  }
+  static Extension _optionalSfixed32Extension = null;
+  static Extension get optionalSfixed32Extension() {
+    if (null == _optionalSfixed32Extension ) {
+      _optionalSfixed32Extension = new Extension("Protobuf_Unittest_TestAllExtensions", "optionalSfixed32Extension", 9, Builder.OSF3);
+    }
+    return _optionalSfixed32Extension;
+  }
+  static Extension _optionalSfixed64Extension = null;
+  static Extension get optionalSfixed64Extension() {
+    if (null == _optionalSfixed64Extension ) {
+      _optionalSfixed64Extension = new Extension("Protobuf_Unittest_TestAllExtensions", "optionalSfixed64Extension", 10, Builder.OSF6);
+    }
+    return _optionalSfixed64Extension;
+  }
+  static Extension _optionalFloatExtension = null;
+  static Extension get optionalFloatExtension() {
+    if (null == _optionalFloatExtension ) {
+      _optionalFloatExtension = new Extension("Protobuf_Unittest_TestAllExtensions", "optionalFloatExtension", 11, Builder.OF);
+    }
+    return _optionalFloatExtension;
+  }
+  static Extension _optionalDoubleExtension = null;
+  static Extension get optionalDoubleExtension() {
+    if (null == _optionalDoubleExtension ) {
+      _optionalDoubleExtension = new Extension("Protobuf_Unittest_TestAllExtensions", "optionalDoubleExtension", 12, Builder.OD);
+    }
+    return _optionalDoubleExtension;
+  }
+  static Extension _optionalBoolExtension = null;
+  static Extension get optionalBoolExtension() {
+    if (null == _optionalBoolExtension ) {
+      _optionalBoolExtension = new Extension("Protobuf_Unittest_TestAllExtensions", "optionalBoolExtension", 13, Builder.OB);
+    }
+    return _optionalBoolExtension;
+  }
+  static Extension _optionalStringExtension = null;
+  static Extension get optionalStringExtension() {
+    if (null == _optionalStringExtension ) {
+      _optionalStringExtension = new Extension("Protobuf_Unittest_TestAllExtensions", "optionalStringExtension", 14, Builder.OS);
+    }
+    return _optionalStringExtension;
+  }
+  static Extension _optionalBytesExtension = null;
+  static Extension get optionalBytesExtension() {
+    if (null == _optionalBytesExtension ) {
+      _optionalBytesExtension = new Extension("Protobuf_Unittest_TestAllExtensions", "optionalBytesExtension", 15, Builder.OY);
+    }
+    return _optionalBytesExtension;
+  }
+  static Extension _optionalGroupExtension = null;
+  static Extension get optionalGroupExtension() {
+    if (null == _optionalGroupExtension ) {
+      _optionalGroupExtension = new Extension("Protobuf_Unittest_TestAllExtensions", "optionalGroupExtension", 16, Builder.OG, () => Protobuf_Unittest_OptionalGroup_extension.defaultInstance, () => new Protobuf_Unittest_OptionalGroup_extension_Builder());
+    }
+    return _optionalGroupExtension;
+  }
+  static Extension _optionalNestedMessageExtension = null;
+  static Extension get optionalNestedMessageExtension() {
+    if (null == _optionalNestedMessageExtension ) {
+      _optionalNestedMessageExtension = new Extension("Protobuf_Unittest_TestAllExtensions", "optionalNestedMessageExtension", 18, Builder.OM, () => Protobuf_Unittest_TestAllTypes_NestedMessage.defaultInstance, () => new Protobuf_Unittest_TestAllTypes_NestedMessage_Builder());
+    }
+    return _optionalNestedMessageExtension;
+  }
+  static Extension _optionalForeignMessageExtension = null;
+  static Extension get optionalForeignMessageExtension() {
+    if (null == _optionalForeignMessageExtension ) {
+      _optionalForeignMessageExtension = new Extension("Protobuf_Unittest_TestAllExtensions", "optionalForeignMessageExtension", 19, Builder.OM, () => Protobuf_Unittest_ForeignMessage.defaultInstance, () => new Protobuf_Unittest_ForeignMessage_Builder());
+    }
+    return _optionalForeignMessageExtension;
+  }
+  static Extension _optionalImportMessageExtension = null;
+  static Extension get optionalImportMessageExtension() {
+    if (null == _optionalImportMessageExtension ) {
+      _optionalImportMessageExtension = new Extension("Protobuf_Unittest_TestAllExtensions", "optionalImportMessageExtension", 20, Builder.OM, () => Protobuf_Unittest_Import_ImportMessage.defaultInstance, () => new Protobuf_Unittest_Import_ImportMessage_Builder());
+    }
+    return _optionalImportMessageExtension;
+  }
+  static Extension _optionalNestedEnumExtension = null;
+  static Extension get optionalNestedEnumExtension() {
+    if (null == _optionalNestedEnumExtension ) {
+      _optionalNestedEnumExtension = new Extension("Protobuf_Unittest_TestAllExtensions", "optionalNestedEnumExtension", 21, Builder.OE, () => Protobuf_Unittest_TestAllTypes_NestedEnum.FOO, null, (var v) => Protobuf_Unittest_TestAllTypes_NestedEnum.valueOf(v));
+    }
+    return _optionalNestedEnumExtension;
+  }
+  static Extension _optionalForeignEnumExtension = null;
+  static Extension get optionalForeignEnumExtension() {
+    if (null == _optionalForeignEnumExtension ) {
+      _optionalForeignEnumExtension = new Extension("Protobuf_Unittest_TestAllExtensions", "optionalForeignEnumExtension", 22, Builder.OE, () => Protobuf_Unittest_ForeignEnum.FOREIGN_FOO, null, (var v) => Protobuf_Unittest_ForeignEnum.valueOf(v));
+    }
+    return _optionalForeignEnumExtension;
+  }
+  static Extension _optionalImportEnumExtension = null;
+  static Extension get optionalImportEnumExtension() {
+    if (null == _optionalImportEnumExtension ) {
+      _optionalImportEnumExtension = new Extension("Protobuf_Unittest_TestAllExtensions", "optionalImportEnumExtension", 23, Builder.OE, () => Protobuf_Unittest_Import_ImportEnum.IMPORT_FOO, null, (var v) => Protobuf_Unittest_Import_ImportEnum.valueOf(v));
+    }
+    return _optionalImportEnumExtension;
+  }
+  static Extension _optionalStringPieceExtension = null;
+  static Extension get optionalStringPieceExtension() {
+    if (null == _optionalStringPieceExtension ) {
+      _optionalStringPieceExtension = new Extension("Protobuf_Unittest_TestAllExtensions", "optionalStringPieceExtension", 24, Builder.OS);
+    }
+    return _optionalStringPieceExtension;
+  }
+  static Extension _optionalCordExtension = null;
+  static Extension get optionalCordExtension() {
+    if (null == _optionalCordExtension ) {
+      _optionalCordExtension = new Extension("Protobuf_Unittest_TestAllExtensions", "optionalCordExtension", 25, Builder.OS);
+    }
+    return _optionalCordExtension;
+  }
+  static Extension _repeatedInt32Extension = null;
+  static Extension get repeatedInt32Extension() {
+    if (null == _repeatedInt32Extension ) {
+      _repeatedInt32Extension = new Extension("Protobuf_Unittest_TestAllExtensions", "repeatedInt32Extension", 31, Builder.P3, () => new PbList<int>(null));
+    }
+    return _repeatedInt32Extension;
+  }
+  static Extension _repeatedInt64Extension = null;
+  static Extension get repeatedInt64Extension() {
+    if (null == _repeatedInt64Extension ) {
+      _repeatedInt64Extension = new Extension("Protobuf_Unittest_TestAllExtensions", "repeatedInt64Extension", 32, Builder.P6, () => new PbList<int>(null));
+    }
+    return _repeatedInt64Extension;
+  }
+  static Extension _repeatedUint32Extension = null;
+  static Extension get repeatedUint32Extension() {
+    if (null == _repeatedUint32Extension ) {
+      _repeatedUint32Extension = new Extension("Protobuf_Unittest_TestAllExtensions", "repeatedUint32Extension", 33, Builder.PU3, () => new PbList<int>(null));
+    }
+    return _repeatedUint32Extension;
+  }
+  static Extension _repeatedUint64Extension = null;
+  static Extension get repeatedUint64Extension() {
+    if (null == _repeatedUint64Extension ) {
+      _repeatedUint64Extension = new Extension("Protobuf_Unittest_TestAllExtensions", "repeatedUint64Extension", 34, Builder.PU6, () => new PbList<int>(null));
+    }
+    return _repeatedUint64Extension;
+  }
+  static Extension _repeatedSint32Extension = null;
+  static Extension get repeatedSint32Extension() {
+    if (null == _repeatedSint32Extension ) {
+      _repeatedSint32Extension = new Extension("Protobuf_Unittest_TestAllExtensions", "repeatedSint32Extension", 35, Builder.PS3, () => new PbList<int>(null));
+    }
+    return _repeatedSint32Extension;
+  }
+  static Extension _repeatedSint64Extension = null;
+  static Extension get repeatedSint64Extension() {
+    if (null == _repeatedSint64Extension ) {
+      _repeatedSint64Extension = new Extension("Protobuf_Unittest_TestAllExtensions", "repeatedSint64Extension", 36, Builder.PS6, () => new PbList<int>(null));
+    }
+    return _repeatedSint64Extension;
+  }
+  static Extension _repeatedFixed32Extension = null;
+  static Extension get repeatedFixed32Extension() {
+    if (null == _repeatedFixed32Extension ) {
+      _repeatedFixed32Extension = new Extension("Protobuf_Unittest_TestAllExtensions", "repeatedFixed32Extension", 37, Builder.PF3, () => new PbList<int>(null));
+    }
+    return _repeatedFixed32Extension;
+  }
+  static Extension _repeatedFixed64Extension = null;
+  static Extension get repeatedFixed64Extension() {
+    if (null == _repeatedFixed64Extension ) {
+      _repeatedFixed64Extension = new Extension("Protobuf_Unittest_TestAllExtensions", "repeatedFixed64Extension", 38, Builder.PF6, () => new PbList<int>(null));
+    }
+    return _repeatedFixed64Extension;
+  }
+  static Extension _repeatedSfixed32Extension = null;
+  static Extension get repeatedSfixed32Extension() {
+    if (null == _repeatedSfixed32Extension ) {
+      _repeatedSfixed32Extension = new Extension("Protobuf_Unittest_TestAllExtensions", "repeatedSfixed32Extension", 39, Builder.PSF3, () => new PbList<int>(null));
+    }
+    return _repeatedSfixed32Extension;
+  }
+  static Extension _repeatedSfixed64Extension = null;
+  static Extension get repeatedSfixed64Extension() {
+    if (null == _repeatedSfixed64Extension ) {
+      _repeatedSfixed64Extension = new Extension("Protobuf_Unittest_TestAllExtensions", "repeatedSfixed64Extension", 40, Builder.PSF6, () => new PbList<int>(null));
+    }
+    return _repeatedSfixed64Extension;
+  }
+  static Extension _repeatedFloatExtension = null;
+  static Extension get repeatedFloatExtension() {
+    if (null == _repeatedFloatExtension ) {
+      _repeatedFloatExtension = new Extension("Protobuf_Unittest_TestAllExtensions", "repeatedFloatExtension", 41, Builder.PF, () => new PbList<double>(null));
+    }
+    return _repeatedFloatExtension;
+  }
+  static Extension _repeatedDoubleExtension = null;
+  static Extension get repeatedDoubleExtension() {
+    if (null == _repeatedDoubleExtension ) {
+      _repeatedDoubleExtension = new Extension("Protobuf_Unittest_TestAllExtensions", "repeatedDoubleExtension", 42, Builder.PD, () => new PbList<double>(null));
+    }
+    return _repeatedDoubleExtension;
+  }
+  static Extension _repeatedBoolExtension = null;
+  static Extension get repeatedBoolExtension() {
+    if (null == _repeatedBoolExtension ) {
+      _repeatedBoolExtension = new Extension("Protobuf_Unittest_TestAllExtensions", "repeatedBoolExtension", 43, Builder.PB, () => new PbList<bool>(null));
+    }
+    return _repeatedBoolExtension;
+  }
+  static Extension _repeatedStringExtension = null;
+  static Extension get repeatedStringExtension() {
+    if (null == _repeatedStringExtension ) {
+      _repeatedStringExtension = new Extension("Protobuf_Unittest_TestAllExtensions", "repeatedStringExtension", 44, Builder.PS, () => new PbList<String>(null));
+    }
+    return _repeatedStringExtension;
+  }
+  static Extension _repeatedBytesExtension = null;
+  static Extension get repeatedBytesExtension() {
+    if (null == _repeatedBytesExtension ) {
+      _repeatedBytesExtension = new Extension("Protobuf_Unittest_TestAllExtensions", "repeatedBytesExtension", 45, Builder.PY, () => new PbList<List<int>>(null));
+    }
+    return _repeatedBytesExtension;
+  }
+  static Extension _repeatedGroupExtension = null;
+  static Extension get repeatedGroupExtension() {
+    if (null == _repeatedGroupExtension ) {
+      _repeatedGroupExtension = new Extension("Protobuf_Unittest_TestAllExtensions", "repeatedGroupExtension", 46, Builder.PG, () => new PbList<Protobuf_Unittest_RepeatedGroup_extension>(null), () => new Protobuf_Unittest_RepeatedGroup_extension_Builder());
+    }
+    return _repeatedGroupExtension;
+  }
+  static Extension _repeatedNestedMessageExtension = null;
+  static Extension get repeatedNestedMessageExtension() {
+    if (null == _repeatedNestedMessageExtension ) {
+      _repeatedNestedMessageExtension = new Extension("Protobuf_Unittest_TestAllExtensions", "repeatedNestedMessageExtension", 48, Builder.PM, () => new PbList<Protobuf_Unittest_TestAllTypes_NestedMessage>(null), () => new Protobuf_Unittest_TestAllTypes_NestedMessage_Builder());
+    }
+    return _repeatedNestedMessageExtension;
+  }
+  static Extension _repeatedForeignMessageExtension = null;
+  static Extension get repeatedForeignMessageExtension() {
+    if (null == _repeatedForeignMessageExtension ) {
+      _repeatedForeignMessageExtension = new Extension("Protobuf_Unittest_TestAllExtensions", "repeatedForeignMessageExtension", 49, Builder.PM, () => new PbList<Protobuf_Unittest_ForeignMessage>(null), () => new Protobuf_Unittest_ForeignMessage_Builder());
+    }
+    return _repeatedForeignMessageExtension;
+  }
+  static Extension _repeatedImportMessageExtension = null;
+  static Extension get repeatedImportMessageExtension() {
+    if (null == _repeatedImportMessageExtension ) {
+      _repeatedImportMessageExtension = new Extension("Protobuf_Unittest_TestAllExtensions", "repeatedImportMessageExtension", 50, Builder.PM, () => new PbList<Protobuf_Unittest_Import_ImportMessage>(null), () => new Protobuf_Unittest_Import_ImportMessage_Builder());
+    }
+    return _repeatedImportMessageExtension;
+  }
+  static Extension _repeatedNestedEnumExtension = null;
+  static Extension get repeatedNestedEnumExtension() {
+    if (null == _repeatedNestedEnumExtension ) {
+      _repeatedNestedEnumExtension = new Extension("Protobuf_Unittest_TestAllExtensions", "repeatedNestedEnumExtension", 51, Builder.PE, () => new PbList<Protobuf_Unittest_TestAllTypes_NestedEnum>(null), null, (var v) => Protobuf_Unittest_TestAllTypes_NestedEnum.valueOf(v));
+    }
+    return _repeatedNestedEnumExtension;
+  }
+  static Extension _repeatedForeignEnumExtension = null;
+  static Extension get repeatedForeignEnumExtension() {
+    if (null == _repeatedForeignEnumExtension ) {
+      _repeatedForeignEnumExtension = new Extension("Protobuf_Unittest_TestAllExtensions", "repeatedForeignEnumExtension", 52, Builder.PE, () => new PbList<Protobuf_Unittest_ForeignEnum>(null), null, (var v) => Protobuf_Unittest_ForeignEnum.valueOf(v));
+    }
+    return _repeatedForeignEnumExtension;
+  }
+  static Extension _repeatedImportEnumExtension = null;
+  static Extension get repeatedImportEnumExtension() {
+    if (null == _repeatedImportEnumExtension ) {
+      _repeatedImportEnumExtension = new Extension("Protobuf_Unittest_TestAllExtensions", "repeatedImportEnumExtension", 53, Builder.PE, () => new PbList<Protobuf_Unittest_Import_ImportEnum>(null), null, (var v) => Protobuf_Unittest_Import_ImportEnum.valueOf(v));
+    }
+    return _repeatedImportEnumExtension;
+  }
+  static Extension _repeatedStringPieceExtension = null;
+  static Extension get repeatedStringPieceExtension() {
+    if (null == _repeatedStringPieceExtension ) {
+      _repeatedStringPieceExtension = new Extension("Protobuf_Unittest_TestAllExtensions", "repeatedStringPieceExtension", 54, Builder.PS, () => new PbList<String>(null));
+    }
+    return _repeatedStringPieceExtension;
+  }
+  static Extension _repeatedCordExtension = null;
+  static Extension get repeatedCordExtension() {
+    if (null == _repeatedCordExtension ) {
+      _repeatedCordExtension = new Extension("Protobuf_Unittest_TestAllExtensions", "repeatedCordExtension", 55, Builder.PS, () => new PbList<String>(null));
+    }
+    return _repeatedCordExtension;
+  }
+  static Extension _defaultInt32Extension = null;
+  static Extension get defaultInt32Extension() {
+    if (null == _defaultInt32Extension ) {
+      _defaultInt32Extension = new Extension("Protobuf_Unittest_TestAllExtensions", "defaultInt32Extension", 61, Builder.O3, () => 41);
+    }
+    return _defaultInt32Extension;
+  }
+  static Extension _defaultInt64Extension = null;
+  static Extension get defaultInt64Extension() {
+    if (null == _defaultInt64Extension ) {
+      _defaultInt64Extension = new Extension("Protobuf_Unittest_TestAllExtensions", "defaultInt64Extension", 62, Builder.O6, () => 42);
+    }
+    return _defaultInt64Extension;
+  }
+  static Extension _defaultUint32Extension = null;
+  static Extension get defaultUint32Extension() {
+    if (null == _defaultUint32Extension ) {
+      _defaultUint32Extension = new Extension("Protobuf_Unittest_TestAllExtensions", "defaultUint32Extension", 63, Builder.OU3, () => 43);
+    }
+    return _defaultUint32Extension;
+  }
+  static Extension _defaultUint64Extension = null;
+  static Extension get defaultUint64Extension() {
+    if (null == _defaultUint64Extension ) {
+      _defaultUint64Extension = new Extension("Protobuf_Unittest_TestAllExtensions", "defaultUint64Extension", 64, Builder.OU6, () => 44);
+    }
+    return _defaultUint64Extension;
+  }
+  static Extension _defaultSint32Extension = null;
+  static Extension get defaultSint32Extension() {
+    if (null == _defaultSint32Extension ) {
+      _defaultSint32Extension = new Extension("Protobuf_Unittest_TestAllExtensions", "defaultSint32Extension", 65, Builder.OS3, () => -45);
+    }
+    return _defaultSint32Extension;
+  }
+  static Extension _defaultSint64Extension = null;
+  static Extension get defaultSint64Extension() {
+    if (null == _defaultSint64Extension ) {
+      _defaultSint64Extension = new Extension("Protobuf_Unittest_TestAllExtensions", "defaultSint64Extension", 66, Builder.OS6, () => 46);
+    }
+    return _defaultSint64Extension;
+  }
+  static Extension _defaultFixed32Extension = null;
+  static Extension get defaultFixed32Extension() {
+    if (null == _defaultFixed32Extension ) {
+      _defaultFixed32Extension = new Extension("Protobuf_Unittest_TestAllExtensions", "defaultFixed32Extension", 67, Builder.OF3, () => 47);
+    }
+    return _defaultFixed32Extension;
+  }
+  static Extension _defaultFixed64Extension = null;
+  static Extension get defaultFixed64Extension() {
+    if (null == _defaultFixed64Extension ) {
+      _defaultFixed64Extension = new Extension("Protobuf_Unittest_TestAllExtensions", "defaultFixed64Extension", 68, Builder.OF6, () => 48);
+    }
+    return _defaultFixed64Extension;
+  }
+  static Extension _defaultSfixed32Extension = null;
+  static Extension get defaultSfixed32Extension() {
+    if (null == _defaultSfixed32Extension ) {
+      _defaultSfixed32Extension = new Extension("Protobuf_Unittest_TestAllExtensions", "defaultSfixed32Extension", 69, Builder.OSF3, () => 49);
+    }
+    return _defaultSfixed32Extension;
+  }
+  static Extension _defaultSfixed64Extension = null;
+  static Extension get defaultSfixed64Extension() {
+    if (null == _defaultSfixed64Extension ) {
+      _defaultSfixed64Extension = new Extension("Protobuf_Unittest_TestAllExtensions", "defaultSfixed64Extension", 70, Builder.OSF6, () => -50);
+    }
+    return _defaultSfixed64Extension;
+  }
+  static Extension _defaultFloatExtension = null;
+  static Extension get defaultFloatExtension() {
+    if (null == _defaultFloatExtension ) {
+      _defaultFloatExtension = new Extension("Protobuf_Unittest_TestAllExtensions", "defaultFloatExtension", 71, Builder.OF, () => 51.5);
+    }
+    return _defaultFloatExtension;
+  }
+  static Extension _defaultDoubleExtension = null;
+  static Extension get defaultDoubleExtension() {
+    if (null == _defaultDoubleExtension ) {
+      _defaultDoubleExtension = new Extension("Protobuf_Unittest_TestAllExtensions", "defaultDoubleExtension", 72, Builder.OD, () => 52000.0);
+    }
+    return _defaultDoubleExtension;
+  }
+  static Extension _defaultBoolExtension = null;
+  static Extension get defaultBoolExtension() {
+    if (null == _defaultBoolExtension ) {
+      _defaultBoolExtension = new Extension("Protobuf_Unittest_TestAllExtensions", "defaultBoolExtension", 73, Builder.OB, () => true);
+    }
+    return _defaultBoolExtension;
+  }
+  static Extension _defaultStringExtension = null;
+  static Extension get defaultStringExtension() {
+    if (null == _defaultStringExtension ) {
+      _defaultStringExtension = new Extension("Protobuf_Unittest_TestAllExtensions", "defaultStringExtension", 74, Builder.OS, () => 'hello');
+    }
+    return _defaultStringExtension;
+  }
+  static Extension _defaultBytesExtension = null;
+  static Extension get defaultBytesExtension() {
+    if (null == _defaultBytesExtension ) {
+      _defaultBytesExtension = new Extension("Protobuf_Unittest_TestAllExtensions", "defaultBytesExtension", 75, Builder.OY, () => <int>[0x77,0x6f,0x72,0x6c,0x64]);
+    }
+    return _defaultBytesExtension;
+  }
+  static Extension _defaultNestedEnumExtension = null;
+  static Extension get defaultNestedEnumExtension() {
+    if (null == _defaultNestedEnumExtension ) {
+      _defaultNestedEnumExtension = new Extension("Protobuf_Unittest_TestAllExtensions", "defaultNestedEnumExtension", 81, Builder.OE, () => Protobuf_Unittest_TestAllTypes_NestedEnum.BAR, null, (var v) => Protobuf_Unittest_TestAllTypes_NestedEnum.valueOf(v));
+    }
+    return _defaultNestedEnumExtension;
+  }
+  static Extension _defaultForeignEnumExtension = null;
+  static Extension get defaultForeignEnumExtension() {
+    if (null == _defaultForeignEnumExtension ) {
+      _defaultForeignEnumExtension = new Extension("Protobuf_Unittest_TestAllExtensions", "defaultForeignEnumExtension", 82, Builder.OE, () => Protobuf_Unittest_ForeignEnum.FOREIGN_BAR, null, (var v) => Protobuf_Unittest_ForeignEnum.valueOf(v));
+    }
+    return _defaultForeignEnumExtension;
+  }
+  static Extension _defaultImportEnumExtension = null;
+  static Extension get defaultImportEnumExtension() {
+    if (null == _defaultImportEnumExtension ) {
+      _defaultImportEnumExtension = new Extension("Protobuf_Unittest_TestAllExtensions", "defaultImportEnumExtension", 83, Builder.OE, () => Protobuf_Unittest_Import_ImportEnum.IMPORT_BAR, null, (var v) => Protobuf_Unittest_Import_ImportEnum.valueOf(v));
+    }
+    return _defaultImportEnumExtension;
+  }
+  static Extension _defaultStringPieceExtension = null;
+  static Extension get defaultStringPieceExtension() {
+    if (null == _defaultStringPieceExtension ) {
+      _defaultStringPieceExtension = new Extension("Protobuf_Unittest_TestAllExtensions", "defaultStringPieceExtension", 84, Builder.OS, () => 'abc');
+    }
+    return _defaultStringPieceExtension;
+  }
+  static Extension _defaultCordExtension = null;
+  static Extension get defaultCordExtension() {
+    if (null == _defaultCordExtension ) {
+      _defaultCordExtension = new Extension("Protobuf_Unittest_TestAllExtensions", "defaultCordExtension", 85, Builder.OS, () => '123');
+    }
+    return _defaultCordExtension;
+  }
+  static Extension _myExtensionString = null;
+  static Extension get myExtensionString() {
+    if (null == _myExtensionString ) {
+      _myExtensionString = new Extension("Protobuf_Unittest_TestFieldOrderings", "myExtensionString", 50, Builder.OS);
+    }
+    return _myExtensionString;
+  }
+  static Extension _myExtensionInt = null;
+  static Extension get myExtensionInt() {
+    if (null == _myExtensionInt ) {
+      _myExtensionInt = new Extension("Protobuf_Unittest_TestFieldOrderings", "myExtensionInt", 5, Builder.O3);
+    }
+    return _myExtensionInt;
+  }
+  static Extension _packedInt32Extension = null;
+  static Extension get packedInt32Extension() {
+    if (null == _packedInt32Extension ) {
+      _packedInt32Extension = new Extension("Protobuf_Unittest_TestPackedExtensions", "packedInt32Extension", 90, Builder.K3, () => new PbList<int>(null));
+    }
+    return _packedInt32Extension;
+  }
+  static Extension _packedInt64Extension = null;
+  static Extension get packedInt64Extension() {
+    if (null == _packedInt64Extension ) {
+      _packedInt64Extension = new Extension("Protobuf_Unittest_TestPackedExtensions", "packedInt64Extension", 91, Builder.K6, () => new PbList<int>(null));
+    }
+    return _packedInt64Extension;
+  }
+  static Extension _packedUint32Extension = null;
+  static Extension get packedUint32Extension() {
+    if (null == _packedUint32Extension ) {
+      _packedUint32Extension = new Extension("Protobuf_Unittest_TestPackedExtensions", "packedUint32Extension", 92, Builder.KU3, () => new PbList<int>(null));
+    }
+    return _packedUint32Extension;
+  }
+  static Extension _packedUint64Extension = null;
+  static Extension get packedUint64Extension() {
+    if (null == _packedUint64Extension ) {
+      _packedUint64Extension = new Extension("Protobuf_Unittest_TestPackedExtensions", "packedUint64Extension", 93, Builder.KU6, () => new PbList<int>(null));
+    }
+    return _packedUint64Extension;
+  }
+  static Extension _packedSint32Extension = null;
+  static Extension get packedSint32Extension() {
+    if (null == _packedSint32Extension ) {
+      _packedSint32Extension = new Extension("Protobuf_Unittest_TestPackedExtensions", "packedSint32Extension", 94, Builder.KS3, () => new PbList<int>(null));
+    }
+    return _packedSint32Extension;
+  }
+  static Extension _packedSint64Extension = null;
+  static Extension get packedSint64Extension() {
+    if (null == _packedSint64Extension ) {
+      _packedSint64Extension = new Extension("Protobuf_Unittest_TestPackedExtensions", "packedSint64Extension", 95, Builder.KS6, () => new PbList<int>(null));
+    }
+    return _packedSint64Extension;
+  }
+  static Extension _packedFixed32Extension = null;
+  static Extension get packedFixed32Extension() {
+    if (null == _packedFixed32Extension ) {
+      _packedFixed32Extension = new Extension("Protobuf_Unittest_TestPackedExtensions", "packedFixed32Extension", 96, Builder.KF3, () => new PbList<int>(null));
+    }
+    return _packedFixed32Extension;
+  }
+  static Extension _packedFixed64Extension = null;
+  static Extension get packedFixed64Extension() {
+    if (null == _packedFixed64Extension ) {
+      _packedFixed64Extension = new Extension("Protobuf_Unittest_TestPackedExtensions", "packedFixed64Extension", 97, Builder.KF6, () => new PbList<int>(null));
+    }
+    return _packedFixed64Extension;
+  }
+  static Extension _packedSfixed32Extension = null;
+  static Extension get packedSfixed32Extension() {
+    if (null == _packedSfixed32Extension ) {
+      _packedSfixed32Extension = new Extension("Protobuf_Unittest_TestPackedExtensions", "packedSfixed32Extension", 98, Builder.KSF3, () => new PbList<int>(null));
+    }
+    return _packedSfixed32Extension;
+  }
+  static Extension _packedSfixed64Extension = null;
+  static Extension get packedSfixed64Extension() {
+    if (null == _packedSfixed64Extension ) {
+      _packedSfixed64Extension = new Extension("Protobuf_Unittest_TestPackedExtensions", "packedSfixed64Extension", 99, Builder.KSF6, () => new PbList<int>(null));
+    }
+    return _packedSfixed64Extension;
+  }
+  static Extension _packedFloatExtension = null;
+  static Extension get packedFloatExtension() {
+    if (null == _packedFloatExtension ) {
+      _packedFloatExtension = new Extension("Protobuf_Unittest_TestPackedExtensions", "packedFloatExtension", 100, Builder.KF, () => new PbList<double>(null));
+    }
+    return _packedFloatExtension;
+  }
+  static Extension _packedDoubleExtension = null;
+  static Extension get packedDoubleExtension() {
+    if (null == _packedDoubleExtension ) {
+      _packedDoubleExtension = new Extension("Protobuf_Unittest_TestPackedExtensions", "packedDoubleExtension", 101, Builder.KD, () => new PbList<double>(null));
+    }
+    return _packedDoubleExtension;
+  }
+  static Extension _packedBoolExtension = null;
+  static Extension get packedBoolExtension() {
+    if (null == _packedBoolExtension ) {
+      _packedBoolExtension = new Extension("Protobuf_Unittest_TestPackedExtensions", "packedBoolExtension", 102, Builder.KB, () => new PbList<bool>(null));
+    }
+    return _packedBoolExtension;
+  }
+  static Extension _packedEnumExtension = null;
+  static Extension get packedEnumExtension() {
+    if (null == _packedEnumExtension ) {
+      _packedEnumExtension = new Extension("Protobuf_Unittest_TestPackedExtensions", "packedEnumExtension", 103, Builder.KE, () => new PbList<Protobuf_Unittest_ForeignEnum>(null), null, (var v) => Protobuf_Unittest_ForeignEnum.valueOf(v));
+    }
+    return _packedEnumExtension;
+  }
+  static void registerAllExtensions(ExtensionRegistry registry) {
+    registry.add(Protobuf_Unittest_TestNestedExtension.test);
+    registry.add(Protobuf_Unittest_TestRequired.single);
+    registry.add(Protobuf_Unittest_TestRequired.multi);
+    registry.add(optionalInt32Extension);
+    registry.add(optionalInt64Extension);
+    registry.add(optionalUint32Extension);
+    registry.add(optionalUint64Extension);
+    registry.add(optionalSint32Extension);
+    registry.add(optionalSint64Extension);
+    registry.add(optionalFixed32Extension);
+    registry.add(optionalFixed64Extension);
+    registry.add(optionalSfixed32Extension);
+    registry.add(optionalSfixed64Extension);
+    registry.add(optionalFloatExtension);
+    registry.add(optionalDoubleExtension);
+    registry.add(optionalBoolExtension);
+    registry.add(optionalStringExtension);
+    registry.add(optionalBytesExtension);
+    registry.add(optionalGroupExtension);
+    registry.add(optionalNestedMessageExtension);
+    registry.add(optionalForeignMessageExtension);
+    registry.add(optionalImportMessageExtension);
+    registry.add(optionalNestedEnumExtension);
+    registry.add(optionalForeignEnumExtension);
+    registry.add(optionalImportEnumExtension);
+    registry.add(optionalStringPieceExtension);
+    registry.add(optionalCordExtension);
+    registry.add(repeatedInt32Extension);
+    registry.add(repeatedInt64Extension);
+    registry.add(repeatedUint32Extension);
+    registry.add(repeatedUint64Extension);
+    registry.add(repeatedSint32Extension);
+    registry.add(repeatedSint64Extension);
+    registry.add(repeatedFixed32Extension);
+    registry.add(repeatedFixed64Extension);
+    registry.add(repeatedSfixed32Extension);
+    registry.add(repeatedSfixed64Extension);
+    registry.add(repeatedFloatExtension);
+    registry.add(repeatedDoubleExtension);
+    registry.add(repeatedBoolExtension);
+    registry.add(repeatedStringExtension);
+    registry.add(repeatedBytesExtension);
+    registry.add(repeatedGroupExtension);
+    registry.add(repeatedNestedMessageExtension);
+    registry.add(repeatedForeignMessageExtension);
+    registry.add(repeatedImportMessageExtension);
+    registry.add(repeatedNestedEnumExtension);
+    registry.add(repeatedForeignEnumExtension);
+    registry.add(repeatedImportEnumExtension);
+    registry.add(repeatedStringPieceExtension);
+    registry.add(repeatedCordExtension);
+    registry.add(defaultInt32Extension);
+    registry.add(defaultInt64Extension);
+    registry.add(defaultUint32Extension);
+    registry.add(defaultUint64Extension);
+    registry.add(defaultSint32Extension);
+    registry.add(defaultSint64Extension);
+    registry.add(defaultFixed32Extension);
+    registry.add(defaultFixed64Extension);
+    registry.add(defaultSfixed32Extension);
+    registry.add(defaultSfixed64Extension);
+    registry.add(defaultFloatExtension);
+    registry.add(defaultDoubleExtension);
+    registry.add(defaultBoolExtension);
+    registry.add(defaultStringExtension);
+    registry.add(defaultBytesExtension);
+    registry.add(defaultNestedEnumExtension);
+    registry.add(defaultForeignEnumExtension);
+    registry.add(defaultImportEnumExtension);
+    registry.add(defaultStringPieceExtension);
+    registry.add(defaultCordExtension);
+    registry.add(myExtensionString);
+    registry.add(myExtensionInt);
+    registry.add(packedInt32Extension);
+    registry.add(packedInt64Extension);
+    registry.add(packedUint32Extension);
+    registry.add(packedUint64Extension);
+    registry.add(packedSint32Extension);
+    registry.add(packedSint64Extension);
+    registry.add(packedFixed32Extension);
+    registry.add(packedFixed64Extension);
+    registry.add(packedSfixed32Extension);
+    registry.add(packedSfixed64Extension);
+    registry.add(packedFloatExtension);
+    registry.add(packedDoubleExtension);
+    registry.add(packedBoolExtension);
+    registry.add(packedEnumExtension);
+  }
+}
+