wechat/source/hook/include/google/protobuf/unittest.pb.h

// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: google/protobuf/unittest.proto

#ifndef PROTOBUF_INCLUDED_google_2fprotobuf_2funittest_2eproto
#define PROTOBUF_INCLUDED_google_2fprotobuf_2funittest_2eproto

#include <string>

#include <google/protobuf/stubs/common.h>

#if GOOGLE_PROTOBUF_VERSION < 3006001
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers.  Please update
#error your headers.
#endif
#if 3006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers.  Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_table_driven.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/inlined_string_field.h>
#include <google/protobuf/metadata.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/map.h>  // IWYU pragma: export
#include <google/protobuf/map_entry.h>
#include <google/protobuf/map_field_inl.h>
#include <google/protobuf/generated_enum_reflection.h>
#include <google/protobuf/service.h>
#include <google/protobuf/unknown_field_set.h>
#include <google/protobuf/unittest_import.pb.h>
// @@protoc_insertion_point(includes)
#define PROTOBUF_INTERNAL_EXPORT_protobuf_google_2fprotobuf_2funittest_2eproto 

namespace protobuf_google_2fprotobuf_2funittest_2eproto {
// Internal implementation detail -- do not use these members.
struct TableStruct {
  static const ::google::protobuf::internal::ParseTableField entries[];
  static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
  static const ::google::protobuf::internal::ParseTable schema[91];
  static const ::google::protobuf::internal::FieldMetadata field_metadata[];
  static const ::google::protobuf::internal::SerializationTable serialization_table[];
  static const ::google::protobuf::uint32 offsets[];
};
void AddDescriptors();
}  // namespace protobuf_google_2fprotobuf_2funittest_2eproto
namespace protobuf_unittest {
class BarRequest;
class BarRequestDefaultTypeInternal;
extern BarRequestDefaultTypeInternal _BarRequest_default_instance_;
class BarResponse;
class BarResponseDefaultTypeInternal;
extern BarResponseDefaultTypeInternal _BarResponse_default_instance_;
class BoolMessage;
class BoolMessageDefaultTypeInternal;
extern BoolMessageDefaultTypeInternal _BoolMessage_default_instance_;
class FooClientMessage;
class FooClientMessageDefaultTypeInternal;
extern FooClientMessageDefaultTypeInternal _FooClientMessage_default_instance_;
class FooRequest;
class FooRequestDefaultTypeInternal;
extern FooRequestDefaultTypeInternal _FooRequest_default_instance_;
class FooResponse;
class FooResponseDefaultTypeInternal;
extern FooResponseDefaultTypeInternal _FooResponse_default_instance_;
class FooServerMessage;
class FooServerMessageDefaultTypeInternal;
extern FooServerMessageDefaultTypeInternal _FooServerMessage_default_instance_;
class ForeignMessage;
class ForeignMessageDefaultTypeInternal;
extern ForeignMessageDefaultTypeInternal _ForeignMessage_default_instance_;
class Int32Message;
class Int32MessageDefaultTypeInternal;
extern Int32MessageDefaultTypeInternal _Int32Message_default_instance_;
class Int64Message;
class Int64MessageDefaultTypeInternal;
extern Int64MessageDefaultTypeInternal _Int64Message_default_instance_;
class MoreBytes;
class MoreBytesDefaultTypeInternal;
extern MoreBytesDefaultTypeInternal _MoreBytes_default_instance_;
class MoreString;
class MoreStringDefaultTypeInternal;
extern MoreStringDefaultTypeInternal _MoreString_default_instance_;
class NestedTestAllTypes;
class NestedTestAllTypesDefaultTypeInternal;
extern NestedTestAllTypesDefaultTypeInternal _NestedTestAllTypes_default_instance_;
class OneBytes;
class OneBytesDefaultTypeInternal;
extern OneBytesDefaultTypeInternal _OneBytes_default_instance_;
class OneString;
class OneStringDefaultTypeInternal;
extern OneStringDefaultTypeInternal _OneString_default_instance_;
class OptionalGroup_extension;
class OptionalGroup_extensionDefaultTypeInternal;
extern OptionalGroup_extensionDefaultTypeInternal _OptionalGroup_extension_default_instance_;
class RepeatedGroup_extension;
class RepeatedGroup_extensionDefaultTypeInternal;
extern RepeatedGroup_extensionDefaultTypeInternal _RepeatedGroup_extension_default_instance_;
class SparseEnumMessage;
class SparseEnumMessageDefaultTypeInternal;
extern SparseEnumMessageDefaultTypeInternal _SparseEnumMessage_default_instance_;
class TestAllExtensions;
class TestAllExtensionsDefaultTypeInternal;
extern TestAllExtensionsDefaultTypeInternal _TestAllExtensions_default_instance_;
class TestAllTypes;
class TestAllTypesDefaultTypeInternal;
extern TestAllTypesDefaultTypeInternal _TestAllTypes_default_instance_;
class TestAllTypes_NestedMessage;
class TestAllTypes_NestedMessageDefaultTypeInternal;
extern TestAllTypes_NestedMessageDefaultTypeInternal _TestAllTypes_NestedMessage_default_instance_;
class TestAllTypes_OptionalGroup;
class TestAllTypes_OptionalGroupDefaultTypeInternal;
extern TestAllTypes_OptionalGroupDefaultTypeInternal _TestAllTypes_OptionalGroup_default_instance_;
class TestAllTypes_RepeatedGroup;
class TestAllTypes_RepeatedGroupDefaultTypeInternal;
extern TestAllTypes_RepeatedGroupDefaultTypeInternal _TestAllTypes_RepeatedGroup_default_instance_;
class TestCamelCaseFieldNames;
class TestCamelCaseFieldNamesDefaultTypeInternal;
extern TestCamelCaseFieldNamesDefaultTypeInternal _TestCamelCaseFieldNames_default_instance_;
class TestCommentInjectionMessage;
class TestCommentInjectionMessageDefaultTypeInternal;
extern TestCommentInjectionMessageDefaultTypeInternal _TestCommentInjectionMessage_default_instance_;
class TestDeprecatedFields;
class TestDeprecatedFieldsDefaultTypeInternal;
extern TestDeprecatedFieldsDefaultTypeInternal _TestDeprecatedFields_default_instance_;
class TestDeprecatedMessage;
class TestDeprecatedMessageDefaultTypeInternal;
extern TestDeprecatedMessageDefaultTypeInternal _TestDeprecatedMessage_default_instance_;
class TestDupFieldNumber;
class TestDupFieldNumberDefaultTypeInternal;
extern TestDupFieldNumberDefaultTypeInternal _TestDupFieldNumber_default_instance_;
class TestDupFieldNumber_Bar;
class TestDupFieldNumber_BarDefaultTypeInternal;
extern TestDupFieldNumber_BarDefaultTypeInternal _TestDupFieldNumber_Bar_default_instance_;
class TestDupFieldNumber_Foo;
class TestDupFieldNumber_FooDefaultTypeInternal;
extern TestDupFieldNumber_FooDefaultTypeInternal _TestDupFieldNumber_Foo_default_instance_;
class TestDynamicExtensions;
class TestDynamicExtensionsDefaultTypeInternal;
extern TestDynamicExtensionsDefaultTypeInternal _TestDynamicExtensions_default_instance_;
class TestDynamicExtensions_DynamicMessageType;
class TestDynamicExtensions_DynamicMessageTypeDefaultTypeInternal;
extern TestDynamicExtensions_DynamicMessageTypeDefaultTypeInternal _TestDynamicExtensions_DynamicMessageType_default_instance_;
class TestEagerMessage;
class TestEagerMessageDefaultTypeInternal;
extern TestEagerMessageDefaultTypeInternal _TestEagerMessage_default_instance_;
class TestEmptyMessage;
class TestEmptyMessageDefaultTypeInternal;
extern TestEmptyMessageDefaultTypeInternal _TestEmptyMessage_default_instance_;
class TestEmptyMessageWithExtensions;
class TestEmptyMessageWithExtensionsDefaultTypeInternal;
extern TestEmptyMessageWithExtensionsDefaultTypeInternal _TestEmptyMessageWithExtensions_default_instance_;
class TestExtensionInsideTable;
class TestExtensionInsideTableDefaultTypeInternal;
extern TestExtensionInsideTableDefaultTypeInternal _TestExtensionInsideTable_default_instance_;
class TestExtensionOrderings1;
class TestExtensionOrderings1DefaultTypeInternal;
extern TestExtensionOrderings1DefaultTypeInternal _TestExtensionOrderings1_default_instance_;
class TestExtensionOrderings2;
class TestExtensionOrderings2DefaultTypeInternal;
extern TestExtensionOrderings2DefaultTypeInternal _TestExtensionOrderings2_default_instance_;
class TestExtensionOrderings2_TestExtensionOrderings3;
class TestExtensionOrderings2_TestExtensionOrderings3DefaultTypeInternal;
extern TestExtensionOrderings2_TestExtensionOrderings3DefaultTypeInternal _TestExtensionOrderings2_TestExtensionOrderings3_default_instance_;
class TestExtremeDefaultValues;
class TestExtremeDefaultValuesDefaultTypeInternal;
extern TestExtremeDefaultValuesDefaultTypeInternal _TestExtremeDefaultValues_default_instance_;
class TestFieldOrderings;
class TestFieldOrderingsDefaultTypeInternal;
extern TestFieldOrderingsDefaultTypeInternal _TestFieldOrderings_default_instance_;
class TestFieldOrderings_NestedMessage;
class TestFieldOrderings_NestedMessageDefaultTypeInternal;
extern TestFieldOrderings_NestedMessageDefaultTypeInternal _TestFieldOrderings_NestedMessage_default_instance_;
class TestForeignNested;
class TestForeignNestedDefaultTypeInternal;
extern TestForeignNestedDefaultTypeInternal _TestForeignNested_default_instance_;
class TestGroup;
class TestGroupDefaultTypeInternal;
extern TestGroupDefaultTypeInternal _TestGroup_default_instance_;
class TestGroupExtension;
class TestGroupExtensionDefaultTypeInternal;
extern TestGroupExtensionDefaultTypeInternal _TestGroupExtension_default_instance_;
class TestGroup_OptionalGroup;
class TestGroup_OptionalGroupDefaultTypeInternal;
extern TestGroup_OptionalGroupDefaultTypeInternal _TestGroup_OptionalGroup_default_instance_;
class TestHugeFieldNumbers;
class TestHugeFieldNumbersDefaultTypeInternal;
extern TestHugeFieldNumbersDefaultTypeInternal _TestHugeFieldNumbers_default_instance_;
class TestHugeFieldNumbers_OptionalGroup;
class TestHugeFieldNumbers_OptionalGroupDefaultTypeInternal;
extern TestHugeFieldNumbers_OptionalGroupDefaultTypeInternal _TestHugeFieldNumbers_OptionalGroup_default_instance_;
class TestHugeFieldNumbers_StringStringMapEntry_DoNotUse;
class TestHugeFieldNumbers_StringStringMapEntry_DoNotUseDefaultTypeInternal;
extern TestHugeFieldNumbers_StringStringMapEntry_DoNotUseDefaultTypeInternal _TestHugeFieldNumbers_StringStringMapEntry_DoNotUse_default_instance_;
class TestIsInitialized;
class TestIsInitializedDefaultTypeInternal;
extern TestIsInitializedDefaultTypeInternal _TestIsInitialized_default_instance_;
class TestIsInitialized_SubMessage;
class TestIsInitialized_SubMessageDefaultTypeInternal;
extern TestIsInitialized_SubMessageDefaultTypeInternal _TestIsInitialized_SubMessage_default_instance_;
class TestIsInitialized_SubMessage_SubGroup;
class TestIsInitialized_SubMessage_SubGroupDefaultTypeInternal;
extern TestIsInitialized_SubMessage_SubGroupDefaultTypeInternal _TestIsInitialized_SubMessage_SubGroup_default_instance_;
class TestJsonName;
class TestJsonNameDefaultTypeInternal;
extern TestJsonNameDefaultTypeInternal _TestJsonName_default_instance_;
class TestLazyMessage;
class TestLazyMessageDefaultTypeInternal;
extern TestLazyMessageDefaultTypeInternal _TestLazyMessage_default_instance_;
class TestMultipleExtensionRanges;
class TestMultipleExtensionRangesDefaultTypeInternal;
extern TestMultipleExtensionRangesDefaultTypeInternal _TestMultipleExtensionRanges_default_instance_;
class TestMutualRecursionA;
class TestMutualRecursionADefaultTypeInternal;
extern TestMutualRecursionADefaultTypeInternal _TestMutualRecursionA_default_instance_;
class TestMutualRecursionA_SubGroup;
class TestMutualRecursionA_SubGroupDefaultTypeInternal;
extern TestMutualRecursionA_SubGroupDefaultTypeInternal _TestMutualRecursionA_SubGroup_default_instance_;
class TestMutualRecursionA_SubMessage;
class TestMutualRecursionA_SubMessageDefaultTypeInternal;
extern TestMutualRecursionA_SubMessageDefaultTypeInternal _TestMutualRecursionA_SubMessage_default_instance_;
class TestMutualRecursionB;
class TestMutualRecursionBDefaultTypeInternal;
extern TestMutualRecursionBDefaultTypeInternal _TestMutualRecursionB_default_instance_;
class TestNestedExtension;
class TestNestedExtensionDefaultTypeInternal;
extern TestNestedExtensionDefaultTypeInternal _TestNestedExtension_default_instance_;
class TestNestedExtension_OptionalGroup_extension;
class TestNestedExtension_OptionalGroup_extensionDefaultTypeInternal;
extern TestNestedExtension_OptionalGroup_extensionDefaultTypeInternal _TestNestedExtension_OptionalGroup_extension_default_instance_;
class TestNestedMessageHasBits;
class TestNestedMessageHasBitsDefaultTypeInternal;
extern TestNestedMessageHasBitsDefaultTypeInternal _TestNestedMessageHasBits_default_instance_;
class TestNestedMessageHasBits_NestedMessage;
class TestNestedMessageHasBits_NestedMessageDefaultTypeInternal;
extern TestNestedMessageHasBits_NestedMessageDefaultTypeInternal _TestNestedMessageHasBits_NestedMessage_default_instance_;
class TestOneof;
class TestOneofDefaultTypeInternal;
extern TestOneofDefaultTypeInternal _TestOneof_default_instance_;
class TestOneof2;
class TestOneof2DefaultTypeInternal;
extern TestOneof2DefaultTypeInternal _TestOneof2_default_instance_;
class TestOneof2_FooGroup;
class TestOneof2_FooGroupDefaultTypeInternal;
extern TestOneof2_FooGroupDefaultTypeInternal _TestOneof2_FooGroup_default_instance_;
class TestOneof2_NestedMessage;
class TestOneof2_NestedMessageDefaultTypeInternal;
extern TestOneof2_NestedMessageDefaultTypeInternal _TestOneof2_NestedMessage_default_instance_;
class TestOneofBackwardsCompatible;
class TestOneofBackwardsCompatibleDefaultTypeInternal;
extern TestOneofBackwardsCompatibleDefaultTypeInternal _TestOneofBackwardsCompatible_default_instance_;
class TestOneofBackwardsCompatible_FooGroup;
class TestOneofBackwardsCompatible_FooGroupDefaultTypeInternal;
extern TestOneofBackwardsCompatible_FooGroupDefaultTypeInternal _TestOneofBackwardsCompatible_FooGroup_default_instance_;
class TestOneof_FooGroup;
class TestOneof_FooGroupDefaultTypeInternal;
extern TestOneof_FooGroupDefaultTypeInternal _TestOneof_FooGroup_default_instance_;
class TestPackedExtensions;
class TestPackedExtensionsDefaultTypeInternal;
extern TestPackedExtensionsDefaultTypeInternal _TestPackedExtensions_default_instance_;
class TestPackedTypes;
class TestPackedTypesDefaultTypeInternal;
extern TestPackedTypesDefaultTypeInternal _TestPackedTypes_default_instance_;
class TestParsingMerge;
class TestParsingMergeDefaultTypeInternal;
extern TestParsingMergeDefaultTypeInternal _TestParsingMerge_default_instance_;
class TestParsingMerge_OptionalGroup;
class TestParsingMerge_OptionalGroupDefaultTypeInternal;
extern TestParsingMerge_OptionalGroupDefaultTypeInternal _TestParsingMerge_OptionalGroup_default_instance_;
class TestParsingMerge_RepeatedFieldsGenerator;
class TestParsingMerge_RepeatedFieldsGeneratorDefaultTypeInternal;
extern TestParsingMerge_RepeatedFieldsGeneratorDefaultTypeInternal _TestParsingMerge_RepeatedFieldsGenerator_default_instance_;
class TestParsingMerge_RepeatedFieldsGenerator_Group1;
class TestParsingMerge_RepeatedFieldsGenerator_Group1DefaultTypeInternal;
extern TestParsingMerge_RepeatedFieldsGenerator_Group1DefaultTypeInternal _TestParsingMerge_RepeatedFieldsGenerator_Group1_default_instance_;
class TestParsingMerge_RepeatedFieldsGenerator_Group2;
class TestParsingMerge_RepeatedFieldsGenerator_Group2DefaultTypeInternal;
extern TestParsingMerge_RepeatedFieldsGenerator_Group2DefaultTypeInternal _TestParsingMerge_RepeatedFieldsGenerator_Group2_default_instance_;
class TestParsingMerge_RepeatedGroup;
class TestParsingMerge_RepeatedGroupDefaultTypeInternal;
extern TestParsingMerge_RepeatedGroupDefaultTypeInternal _TestParsingMerge_RepeatedGroup_default_instance_;
class TestReallyLargeTagNumber;
class TestReallyLargeTagNumberDefaultTypeInternal;
extern TestReallyLargeTagNumberDefaultTypeInternal _TestReallyLargeTagNumber_default_instance_;
class TestRecursiveMessage;
class TestRecursiveMessageDefaultTypeInternal;
extern TestRecursiveMessageDefaultTypeInternal _TestRecursiveMessage_default_instance_;
class TestRepeatedScalarDifferentTagSizes;
class TestRepeatedScalarDifferentTagSizesDefaultTypeInternal;
extern TestRepeatedScalarDifferentTagSizesDefaultTypeInternal _TestRepeatedScalarDifferentTagSizes_default_instance_;
class TestRequired;
class TestRequiredDefaultTypeInternal;
extern TestRequiredDefaultTypeInternal _TestRequired_default_instance_;
class TestRequiredForeign;
class TestRequiredForeignDefaultTypeInternal;
extern TestRequiredForeignDefaultTypeInternal _TestRequiredForeign_default_instance_;
class TestRequiredMessage;
class TestRequiredMessageDefaultTypeInternal;
extern TestRequiredMessageDefaultTypeInternal _TestRequiredMessage_default_instance_;
class TestRequiredOneof;
class TestRequiredOneofDefaultTypeInternal;
extern TestRequiredOneofDefaultTypeInternal _TestRequiredOneof_default_instance_;
class TestRequiredOneof_NestedMessage;
class TestRequiredOneof_NestedMessageDefaultTypeInternal;
extern TestRequiredOneof_NestedMessageDefaultTypeInternal _TestRequiredOneof_NestedMessage_default_instance_;
class TestReservedFields;
class TestReservedFieldsDefaultTypeInternal;
extern TestReservedFieldsDefaultTypeInternal _TestReservedFields_default_instance_;
class TestUnpackedExtensions;
class TestUnpackedExtensionsDefaultTypeInternal;
extern TestUnpackedExtensionsDefaultTypeInternal _TestUnpackedExtensions_default_instance_;
class TestUnpackedTypes;
class TestUnpackedTypesDefaultTypeInternal;
extern TestUnpackedTypesDefaultTypeInternal _TestUnpackedTypes_default_instance_;
class Uint32Message;
class Uint32MessageDefaultTypeInternal;
extern Uint32MessageDefaultTypeInternal _Uint32Message_default_instance_;
class Uint64Message;
class Uint64MessageDefaultTypeInternal;
extern Uint64MessageDefaultTypeInternal _Uint64Message_default_instance_;
}  // namespace protobuf_unittest
namespace google {
namespace protobuf {
template<> ::protobuf_unittest::BarRequest* Arena::CreateMaybeMessage<::protobuf_unittest::BarRequest>(Arena*);
template<> ::protobuf_unittest::BarResponse* Arena::CreateMaybeMessage<::protobuf_unittest::BarResponse>(Arena*);
template<> ::protobuf_unittest::BoolMessage* Arena::CreateMaybeMessage<::protobuf_unittest::BoolMessage>(Arena*);
template<> ::protobuf_unittest::FooClientMessage* Arena::CreateMaybeMessage<::protobuf_unittest::FooClientMessage>(Arena*);
template<> ::protobuf_unittest::FooRequest* Arena::CreateMaybeMessage<::protobuf_unittest::FooRequest>(Arena*);
template<> ::protobuf_unittest::FooResponse* Arena::CreateMaybeMessage<::protobuf_unittest::FooResponse>(Arena*);
template<> ::protobuf_unittest::FooServerMessage* Arena::CreateMaybeMessage<::protobuf_unittest::FooServerMessage>(Arena*);
template<> ::protobuf_unittest::ForeignMessage* Arena::CreateMaybeMessage<::protobuf_unittest::ForeignMessage>(Arena*);
template<> ::protobuf_unittest::Int32Message* Arena::CreateMaybeMessage<::protobuf_unittest::Int32Message>(Arena*);
template<> ::protobuf_unittest::Int64Message* Arena::CreateMaybeMessage<::protobuf_unittest::Int64Message>(Arena*);
template<> ::protobuf_unittest::MoreBytes* Arena::CreateMaybeMessage<::protobuf_unittest::MoreBytes>(Arena*);
template<> ::protobuf_unittest::MoreString* Arena::CreateMaybeMessage<::protobuf_unittest::MoreString>(Arena*);
template<> ::protobuf_unittest::NestedTestAllTypes* Arena::CreateMaybeMessage<::protobuf_unittest::NestedTestAllTypes>(Arena*);
template<> ::protobuf_unittest::OneBytes* Arena::CreateMaybeMessage<::protobuf_unittest::OneBytes>(Arena*);
template<> ::protobuf_unittest::OneString* Arena::CreateMaybeMessage<::protobuf_unittest::OneString>(Arena*);
template<> ::protobuf_unittest::OptionalGroup_extension* Arena::CreateMaybeMessage<::protobuf_unittest::OptionalGroup_extension>(Arena*);
template<> ::protobuf_unittest::RepeatedGroup_extension* Arena::CreateMaybeMessage<::protobuf_unittest::RepeatedGroup_extension>(Arena*);
template<> ::protobuf_unittest::SparseEnumMessage* Arena::CreateMaybeMessage<::protobuf_unittest::SparseEnumMessage>(Arena*);
template<> ::protobuf_unittest::TestAllExtensions* Arena::CreateMaybeMessage<::protobuf_unittest::TestAllExtensions>(Arena*);
template<> ::protobuf_unittest::TestAllTypes* Arena::CreateMaybeMessage<::protobuf_unittest::TestAllTypes>(Arena*);
template<> ::protobuf_unittest::TestAllTypes_NestedMessage* Arena::CreateMaybeMessage<::protobuf_unittest::TestAllTypes_NestedMessage>(Arena*);
template<> ::protobuf_unittest::TestAllTypes_OptionalGroup* Arena::CreateMaybeMessage<::protobuf_unittest::TestAllTypes_OptionalGroup>(Arena*);
template<> ::protobuf_unittest::TestAllTypes_RepeatedGroup* Arena::CreateMaybeMessage<::protobuf_unittest::TestAllTypes_RepeatedGroup>(Arena*);
template<> ::protobuf_unittest::TestCamelCaseFieldNames* Arena::CreateMaybeMessage<::protobuf_unittest::TestCamelCaseFieldNames>(Arena*);
template<> ::protobuf_unittest::TestCommentInjectionMessage* Arena::CreateMaybeMessage<::protobuf_unittest::TestCommentInjectionMessage>(Arena*);
template<> ::protobuf_unittest::TestDeprecatedFields* Arena::CreateMaybeMessage<::protobuf_unittest::TestDeprecatedFields>(Arena*);
template<> ::protobuf_unittest::TestDeprecatedMessage* Arena::CreateMaybeMessage<::protobuf_unittest::TestDeprecatedMessage>(Arena*);
template<> ::protobuf_unittest::TestDupFieldNumber* Arena::CreateMaybeMessage<::protobuf_unittest::TestDupFieldNumber>(Arena*);
template<> ::protobuf_unittest::TestDupFieldNumber_Bar* Arena::CreateMaybeMessage<::protobuf_unittest::TestDupFieldNumber_Bar>(Arena*);
template<> ::protobuf_unittest::TestDupFieldNumber_Foo* Arena::CreateMaybeMessage<::protobuf_unittest::TestDupFieldNumber_Foo>(Arena*);
template<> ::protobuf_unittest::TestDynamicExtensions* Arena::CreateMaybeMessage<::protobuf_unittest::TestDynamicExtensions>(Arena*);
template<> ::protobuf_unittest::TestDynamicExtensions_DynamicMessageType* Arena::CreateMaybeMessage<::protobuf_unittest::TestDynamicExtensions_DynamicMessageType>(Arena*);
template<> ::protobuf_unittest::TestEagerMessage* Arena::CreateMaybeMessage<::protobuf_unittest::TestEagerMessage>(Arena*);
template<> ::protobuf_unittest::TestEmptyMessage* Arena::CreateMaybeMessage<::protobuf_unittest::TestEmptyMessage>(Arena*);
template<> ::protobuf_unittest::TestEmptyMessageWithExtensions* Arena::CreateMaybeMessage<::protobuf_unittest::TestEmptyMessageWithExtensions>(Arena*);
template<> ::protobuf_unittest::TestExtensionInsideTable* Arena::CreateMaybeMessage<::protobuf_unittest::TestExtensionInsideTable>(Arena*);
template<> ::protobuf_unittest::TestExtensionOrderings1* Arena::CreateMaybeMessage<::protobuf_unittest::TestExtensionOrderings1>(Arena*);
template<> ::protobuf_unittest::TestExtensionOrderings2* Arena::CreateMaybeMessage<::protobuf_unittest::TestExtensionOrderings2>(Arena*);
template<> ::protobuf_unittest::TestExtensionOrderings2_TestExtensionOrderings3* Arena::CreateMaybeMessage<::protobuf_unittest::TestExtensionOrderings2_TestExtensionOrderings3>(Arena*);
template<> ::protobuf_unittest::TestExtremeDefaultValues* Arena::CreateMaybeMessage<::protobuf_unittest::TestExtremeDefaultValues>(Arena*);
template<> ::protobuf_unittest::TestFieldOrderings* Arena::CreateMaybeMessage<::protobuf_unittest::TestFieldOrderings>(Arena*);
template<> ::protobuf_unittest::TestFieldOrderings_NestedMessage* Arena::CreateMaybeMessage<::protobuf_unittest::TestFieldOrderings_NestedMessage>(Arena*);
template<> ::protobuf_unittest::TestForeignNested* Arena::CreateMaybeMessage<::protobuf_unittest::TestForeignNested>(Arena*);
template<> ::protobuf_unittest::TestGroup* Arena::CreateMaybeMessage<::protobuf_unittest::TestGroup>(Arena*);
template<> ::protobuf_unittest::TestGroupExtension* Arena::CreateMaybeMessage<::protobuf_unittest::TestGroupExtension>(Arena*);
template<> ::protobuf_unittest::TestGroup_OptionalGroup* Arena::CreateMaybeMessage<::protobuf_unittest::TestGroup_OptionalGroup>(Arena*);
template<> ::protobuf_unittest::TestHugeFieldNumbers* Arena::CreateMaybeMessage<::protobuf_unittest::TestHugeFieldNumbers>(Arena*);
template<> ::protobuf_unittest::TestHugeFieldNumbers_OptionalGroup* Arena::CreateMaybeMessage<::protobuf_unittest::TestHugeFieldNumbers_OptionalGroup>(Arena*);
template<> ::protobuf_unittest::TestHugeFieldNumbers_StringStringMapEntry_DoNotUse* Arena::CreateMaybeMessage<::protobuf_unittest::TestHugeFieldNumbers_StringStringMapEntry_DoNotUse>(Arena*);
template<> ::protobuf_unittest::TestIsInitialized* Arena::CreateMaybeMessage<::protobuf_unittest::TestIsInitialized>(Arena*);
template<> ::protobuf_unittest::TestIsInitialized_SubMessage* Arena::CreateMaybeMessage<::protobuf_unittest::TestIsInitialized_SubMessage>(Arena*);
template<> ::protobuf_unittest::TestIsInitialized_SubMessage_SubGroup* Arena::CreateMaybeMessage<::protobuf_unittest::TestIsInitialized_SubMessage_SubGroup>(Arena*);
template<> ::protobuf_unittest::TestJsonName* Arena::CreateMaybeMessage<::protobuf_unittest::TestJsonName>(Arena*);
template<> ::protobuf_unittest::TestLazyMessage* Arena::CreateMaybeMessage<::protobuf_unittest::TestLazyMessage>(Arena*);
template<> ::protobuf_unittest::TestMultipleExtensionRanges* Arena::CreateMaybeMessage<::protobuf_unittest::TestMultipleExtensionRanges>(Arena*);
template<> ::protobuf_unittest::TestMutualRecursionA* Arena::CreateMaybeMessage<::protobuf_unittest::TestMutualRecursionA>(Arena*);
template<> ::protobuf_unittest::TestMutualRecursionA_SubGroup* Arena::CreateMaybeMessage<::protobuf_unittest::TestMutualRecursionA_SubGroup>(Arena*);
template<> ::protobuf_unittest::TestMutualRecursionA_SubMessage* Arena::CreateMaybeMessage<::protobuf_unittest::TestMutualRecursionA_SubMessage>(Arena*);
template<> ::protobuf_unittest::TestMutualRecursionB* Arena::CreateMaybeMessage<::protobuf_unittest::TestMutualRecursionB>(Arena*);
template<> ::protobuf_unittest::TestNestedExtension* Arena::CreateMaybeMessage<::protobuf_unittest::TestNestedExtension>(Arena*);
template<> ::protobuf_unittest::TestNestedExtension_OptionalGroup_extension* Arena::CreateMaybeMessage<::protobuf_unittest::TestNestedExtension_OptionalGroup_extension>(Arena*);
template<> ::protobuf_unittest::TestNestedMessageHasBits* Arena::CreateMaybeMessage<::protobuf_unittest::TestNestedMessageHasBits>(Arena*);
template<> ::protobuf_unittest::TestNestedMessageHasBits_NestedMessage* Arena::CreateMaybeMessage<::protobuf_unittest::TestNestedMessageHasBits_NestedMessage>(Arena*);
template<> ::protobuf_unittest::TestOneof* Arena::CreateMaybeMessage<::protobuf_unittest::TestOneof>(Arena*);
template<> ::protobuf_unittest::TestOneof2* Arena::CreateMaybeMessage<::protobuf_unittest::TestOneof2>(Arena*);
template<> ::protobuf_unittest::TestOneof2_FooGroup* Arena::CreateMaybeMessage<::protobuf_unittest::TestOneof2_FooGroup>(Arena*);
template<> ::protobuf_unittest::TestOneof2_NestedMessage* Arena::CreateMaybeMessage<::protobuf_unittest::TestOneof2_NestedMessage>(Arena*);
template<> ::protobuf_unittest::TestOneofBackwardsCompatible* Arena::CreateMaybeMessage<::protobuf_unittest::TestOneofBackwardsCompatible>(Arena*);
template<> ::protobuf_unittest::TestOneofBackwardsCompatible_FooGroup* Arena::CreateMaybeMessage<::protobuf_unittest::TestOneofBackwardsCompatible_FooGroup>(Arena*);
template<> ::protobuf_unittest::TestOneof_FooGroup* Arena::CreateMaybeMessage<::protobuf_unittest::TestOneof_FooGroup>(Arena*);
template<> ::protobuf_unittest::TestPackedExtensions* Arena::CreateMaybeMessage<::protobuf_unittest::TestPackedExtensions>(Arena*);
template<> ::protobuf_unittest::TestPackedTypes* Arena::CreateMaybeMessage<::protobuf_unittest::TestPackedTypes>(Arena*);
template<> ::protobuf_unittest::TestParsingMerge* Arena::CreateMaybeMessage<::protobuf_unittest::TestParsingMerge>(Arena*);
template<> ::protobuf_unittest::TestParsingMerge_OptionalGroup* Arena::CreateMaybeMessage<::protobuf_unittest::TestParsingMerge_OptionalGroup>(Arena*);
template<> ::protobuf_unittest::TestParsingMerge_RepeatedFieldsGenerator* Arena::CreateMaybeMessage<::protobuf_unittest::TestParsingMerge_RepeatedFieldsGenerator>(Arena*);
template<> ::protobuf_unittest::TestParsingMerge_RepeatedFieldsGenerator_Group1* Arena::CreateMaybeMessage<::protobuf_unittest::TestParsingMerge_RepeatedFieldsGenerator_Group1>(Arena*);
template<> ::protobuf_unittest::TestParsingMerge_RepeatedFieldsGenerator_Group2* Arena::CreateMaybeMessage<::protobuf_unittest::TestParsingMerge_RepeatedFieldsGenerator_Group2>(Arena*);
template<> ::protobuf_unittest::TestParsingMerge_RepeatedGroup* Arena::CreateMaybeMessage<::protobuf_unittest::TestParsingMerge_RepeatedGroup>(Arena*);
template<> ::protobuf_unittest::TestReallyLargeTagNumber* Arena::CreateMaybeMessage<::protobuf_unittest::TestReallyLargeTagNumber>(Arena*);
template<> ::protobuf_unittest::TestRecursiveMessage* Arena::CreateMaybeMessage<::protobuf_unittest::TestRecursiveMessage>(Arena*);
template<> ::protobuf_unittest::TestRepeatedScalarDifferentTagSizes* Arena::CreateMaybeMessage<::protobuf_unittest::TestRepeatedScalarDifferentTagSizes>(Arena*);
template<> ::protobuf_unittest::TestRequired* Arena::CreateMaybeMessage<::protobuf_unittest::TestRequired>(Arena*);
template<> ::protobuf_unittest::TestRequiredForeign* Arena::CreateMaybeMessage<::protobuf_unittest::TestRequiredForeign>(Arena*);
template<> ::protobuf_unittest::TestRequiredMessage* Arena::CreateMaybeMessage<::protobuf_unittest::TestRequiredMessage>(Arena*);
template<> ::protobuf_unittest::TestRequiredOneof* Arena::CreateMaybeMessage<::protobuf_unittest::TestRequiredOneof>(Arena*);
template<> ::protobuf_unittest::TestRequiredOneof_NestedMessage* Arena::CreateMaybeMessage<::protobuf_unittest::TestRequiredOneof_NestedMessage>(Arena*);
template<> ::protobuf_unittest::TestReservedFields* Arena::CreateMaybeMessage<::protobuf_unittest::TestReservedFields>(Arena*);
template<> ::protobuf_unittest::TestUnpackedExtensions* Arena::CreateMaybeMessage<::protobuf_unittest::TestUnpackedExtensions>(Arena*);
template<> ::protobuf_unittest::TestUnpackedTypes* Arena::CreateMaybeMessage<::protobuf_unittest::TestUnpackedTypes>(Arena*);
template<> ::protobuf_unittest::Uint32Message* Arena::CreateMaybeMessage<::protobuf_unittest::Uint32Message>(Arena*);
template<> ::protobuf_unittest::Uint64Message* Arena::CreateMaybeMessage<::protobuf_unittest::Uint64Message>(Arena*);
}  // namespace protobuf
}  // namespace google
namespace protobuf_unittest {

enum TestAllTypes_NestedEnum {
  TestAllTypes_NestedEnum_FOO = 1,
  TestAllTypes_NestedEnum_BAR = 2,
  TestAllTypes_NestedEnum_BAZ = 3,
  TestAllTypes_NestedEnum_NEG = -1
};
bool TestAllTypes_NestedEnum_IsValid(int value);
const TestAllTypes_NestedEnum TestAllTypes_NestedEnum_NestedEnum_MIN = TestAllTypes_NestedEnum_NEG;
const TestAllTypes_NestedEnum TestAllTypes_NestedEnum_NestedEnum_MAX = TestAllTypes_NestedEnum_BAZ;
const int TestAllTypes_NestedEnum_NestedEnum_ARRAYSIZE = TestAllTypes_NestedEnum_NestedEnum_MAX + 1;

const ::google::protobuf::EnumDescriptor* TestAllTypes_NestedEnum_descriptor();
inline const ::std::string& TestAllTypes_NestedEnum_Name(TestAllTypes_NestedEnum value) {
  return ::google::protobuf::internal::NameOfEnum(
    TestAllTypes_NestedEnum_descriptor(), value);
}
inline bool TestAllTypes_NestedEnum_Parse(
    const ::std::string& name, TestAllTypes_NestedEnum* value) {
  return ::google::protobuf::internal::ParseNamedEnum<TestAllTypes_NestedEnum>(
    TestAllTypes_NestedEnum_descriptor(), name, value);
}
enum TestOneof2_NestedEnum {
  TestOneof2_NestedEnum_FOO = 1,
  TestOneof2_NestedEnum_BAR = 2,
  TestOneof2_NestedEnum_BAZ = 3
};
bool TestOneof2_NestedEnum_IsValid(int value);
const TestOneof2_NestedEnum TestOneof2_NestedEnum_NestedEnum_MIN = TestOneof2_NestedEnum_FOO;
const TestOneof2_NestedEnum TestOneof2_NestedEnum_NestedEnum_MAX = TestOneof2_NestedEnum_BAZ;
const int TestOneof2_NestedEnum_NestedEnum_ARRAYSIZE = TestOneof2_NestedEnum_NestedEnum_MAX + 1;

const ::google::protobuf::EnumDescriptor* TestOneof2_NestedEnum_descriptor();
inline const ::std::string& TestOneof2_NestedEnum_Name(TestOneof2_NestedEnum value) {
  return ::google::protobuf::internal::NameOfEnum(
    TestOneof2_NestedEnum_descriptor(), value);
}
inline bool TestOneof2_NestedEnum_Parse(
    const ::std::string& name, TestOneof2_NestedEnum* value) {
  return ::google::protobuf::internal::ParseNamedEnum<TestOneof2_NestedEnum>(
    TestOneof2_NestedEnum_descriptor(), name, value);
}
enum TestDynamicExtensions_DynamicEnumType {
  TestDynamicExtensions_DynamicEnumType_DYNAMIC_FOO = 2200,
  TestDynamicExtensions_DynamicEnumType_DYNAMIC_BAR = 2201,
  TestDynamicExtensions_DynamicEnumType_DYNAMIC_BAZ = 2202
};
bool TestDynamicExtensions_DynamicEnumType_IsValid(int value);
const TestDynamicExtensions_DynamicEnumType TestDynamicExtensions_DynamicEnumType_DynamicEnumType_MIN = TestDynamicExtensions_DynamicEnumType_DYNAMIC_FOO;
const TestDynamicExtensions_DynamicEnumType TestDynamicExtensions_DynamicEnumType_DynamicEnumType_MAX = TestDynamicExtensions_DynamicEnumType_DYNAMIC_BAZ;
const int TestDynamicExtensions_DynamicEnumType_DynamicEnumType_ARRAYSIZE = TestDynamicExtensions_DynamicEnumType_DynamicEnumType_MAX + 1;

const ::google::protobuf::EnumDescriptor* TestDynamicExtensions_DynamicEnumType_descriptor();
inline const ::std::string& TestDynamicExtensions_DynamicEnumType_Name(TestDynamicExtensions_DynamicEnumType value) {
  return ::google::protobuf::internal::NameOfEnum(
    TestDynamicExtensions_DynamicEnumType_descriptor(), value);
}
inline bool TestDynamicExtensions_DynamicEnumType_Parse(
    const ::std::string& name, TestDynamicExtensions_DynamicEnumType* value) {
  return ::google::protobuf::internal::ParseNamedEnum<TestDynamicExtensions_DynamicEnumType>(
    TestDynamicExtensions_DynamicEnumType_descriptor(), name, value);
}
enum ForeignEnum {
  FOREIGN_FOO = 4,
  FOREIGN_BAR = 5,
  FOREIGN_BAZ = 6
};
bool ForeignEnum_IsValid(int value);
const ForeignEnum ForeignEnum_MIN = FOREIGN_FOO;
const ForeignEnum ForeignEnum_MAX = FOREIGN_BAZ;
const int ForeignEnum_ARRAYSIZE = ForeignEnum_MAX + 1;

const ::google::protobuf::EnumDescriptor* ForeignEnum_descriptor();
inline const ::std::string& ForeignEnum_Name(ForeignEnum value) {
  return ::google::protobuf::internal::NameOfEnum(
    ForeignEnum_descriptor(), value);
}
inline bool ForeignEnum_Parse(
    const ::std::string& name, ForeignEnum* value) {
  return ::google::protobuf::internal::ParseNamedEnum<ForeignEnum>(
    ForeignEnum_descriptor(), name, value);
}
enum TestEnumWithDupValue {
  FOO1 = 1,
  BAR1 = 2,
  BAZ = 3,
  FOO2 = 1,
  BAR2 = 2
};
bool TestEnumWithDupValue_IsValid(int value);
const TestEnumWithDupValue TestEnumWithDupValue_MIN = FOO1;
const TestEnumWithDupValue TestEnumWithDupValue_MAX = BAZ;
const int TestEnumWithDupValue_ARRAYSIZE = TestEnumWithDupValue_MAX + 1;

const ::google::protobuf::EnumDescriptor* TestEnumWithDupValue_descriptor();
inline const ::std::string& TestEnumWithDupValue_Name(TestEnumWithDupValue value) {
  return ::google::protobuf::internal::NameOfEnum(
    TestEnumWithDupValue_descriptor(), value);
}
inline bool TestEnumWithDupValue_Parse(
    const ::std::string& name, TestEnumWithDupValue* value) {
  return ::google::protobuf::internal::ParseNamedEnum<TestEnumWithDupValue>(
    TestEnumWithDupValue_descriptor(), name, value);
}
enum TestSparseEnum {
  SPARSE_A = 123,
  SPARSE_B = 62374,
  SPARSE_C = 12589234,
  SPARSE_D = -15,
  SPARSE_E = -53452,
  SPARSE_F = 0,
  SPARSE_G = 2
};
bool TestSparseEnum_IsValid(int value);
const TestSparseEnum TestSparseEnum_MIN = SPARSE_E;
const TestSparseEnum TestSparseEnum_MAX = SPARSE_C;
const int TestSparseEnum_ARRAYSIZE = TestSparseEnum_MAX + 1;

const ::google::protobuf::EnumDescriptor* TestSparseEnum_descriptor();
inline const ::std::string& TestSparseEnum_Name(TestSparseEnum value) {
  return ::google::protobuf::internal::NameOfEnum(
    TestSparseEnum_descriptor(), value);
}
inline bool TestSparseEnum_Parse(
    const ::std::string& name, TestSparseEnum* value) {
  return ::google::protobuf::internal::ParseNamedEnum<TestSparseEnum>(
    TestSparseEnum_descriptor(), name, value);
}
// ===================================================================

class TestAllTypes_NestedMessage : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.TestAllTypes.NestedMessage) */ {
 public:
  TestAllTypes_NestedMessage();
  virtual ~TestAllTypes_NestedMessage();

  TestAllTypes_NestedMessage(const TestAllTypes_NestedMessage& from);

  inline TestAllTypes_NestedMessage& operator=(const TestAllTypes_NestedMessage& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TestAllTypes_NestedMessage(TestAllTypes_NestedMessage&& from) noexcept
    : TestAllTypes_NestedMessage() {
    *this = ::std::move(from);
  }

  inline TestAllTypes_NestedMessage& operator=(TestAllTypes_NestedMessage&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const TestAllTypes_NestedMessage& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TestAllTypes_NestedMessage* internal_default_instance() {
    return reinterpret_cast<const TestAllTypes_NestedMessage*>(
               &_TestAllTypes_NestedMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  void UnsafeArenaSwap(TestAllTypes_NestedMessage* other);
  void Swap(TestAllTypes_NestedMessage* other);
  friend void swap(TestAllTypes_NestedMessage& a, TestAllTypes_NestedMessage& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline TestAllTypes_NestedMessage* New() const final {
    return CreateMaybeMessage<TestAllTypes_NestedMessage>(NULL);
  }

  TestAllTypes_NestedMessage* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestAllTypes_NestedMessage>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestAllTypes_NestedMessage& from);
  void MergeFrom(const TestAllTypes_NestedMessage& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TestAllTypes_NestedMessage* other);
  protected:
  explicit TestAllTypes_NestedMessage(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional int32 bb = 1;
  bool has_bb() const;
  void clear_bb();
  static const int kBbFieldNumber = 1;
  ::google::protobuf::int32 bb() const;
  void set_bb(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestAllTypes.NestedMessage)
 private:
  void set_has_bb();
  void clear_has_bb();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::int32 bb_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class TestAllTypes_OptionalGroup : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.TestAllTypes.OptionalGroup) */ {
 public:
  TestAllTypes_OptionalGroup();
  virtual ~TestAllTypes_OptionalGroup();

  TestAllTypes_OptionalGroup(const TestAllTypes_OptionalGroup& from);

  inline TestAllTypes_OptionalGroup& operator=(const TestAllTypes_OptionalGroup& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TestAllTypes_OptionalGroup(TestAllTypes_OptionalGroup&& from) noexcept
    : TestAllTypes_OptionalGroup() {
    *this = ::std::move(from);
  }

  inline TestAllTypes_OptionalGroup& operator=(TestAllTypes_OptionalGroup&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const TestAllTypes_OptionalGroup& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TestAllTypes_OptionalGroup* internal_default_instance() {
    return reinterpret_cast<const TestAllTypes_OptionalGroup*>(
               &_TestAllTypes_OptionalGroup_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

  void UnsafeArenaSwap(TestAllTypes_OptionalGroup* other);
  void Swap(TestAllTypes_OptionalGroup* other);
  friend void swap(TestAllTypes_OptionalGroup& a, TestAllTypes_OptionalGroup& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline TestAllTypes_OptionalGroup* New() const final {
    return CreateMaybeMessage<TestAllTypes_OptionalGroup>(NULL);
  }

  TestAllTypes_OptionalGroup* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestAllTypes_OptionalGroup>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestAllTypes_OptionalGroup& from);
  void MergeFrom(const TestAllTypes_OptionalGroup& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TestAllTypes_OptionalGroup* other);
  protected:
  explicit TestAllTypes_OptionalGroup(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional int32 a = 17;
  bool has_a() const;
  void clear_a();
  static const int kAFieldNumber = 17;
  ::google::protobuf::int32 a() const;
  void set_a(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestAllTypes.OptionalGroup)
 private:
  void set_has_a();
  void clear_has_a();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::int32 a_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class TestAllTypes_RepeatedGroup : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.TestAllTypes.RepeatedGroup) */ {
 public:
  TestAllTypes_RepeatedGroup();
  virtual ~TestAllTypes_RepeatedGroup();

  TestAllTypes_RepeatedGroup(const TestAllTypes_RepeatedGroup& from);

  inline TestAllTypes_RepeatedGroup& operator=(const TestAllTypes_RepeatedGroup& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TestAllTypes_RepeatedGroup(TestAllTypes_RepeatedGroup&& from) noexcept
    : TestAllTypes_RepeatedGroup() {
    *this = ::std::move(from);
  }

  inline TestAllTypes_RepeatedGroup& operator=(TestAllTypes_RepeatedGroup&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const TestAllTypes_RepeatedGroup& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TestAllTypes_RepeatedGroup* internal_default_instance() {
    return reinterpret_cast<const TestAllTypes_RepeatedGroup*>(
               &_TestAllTypes_RepeatedGroup_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

  void UnsafeArenaSwap(TestAllTypes_RepeatedGroup* other);
  void Swap(TestAllTypes_RepeatedGroup* other);
  friend void swap(TestAllTypes_RepeatedGroup& a, TestAllTypes_RepeatedGroup& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline TestAllTypes_RepeatedGroup* New() const final {
    return CreateMaybeMessage<TestAllTypes_RepeatedGroup>(NULL);
  }

  TestAllTypes_RepeatedGroup* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestAllTypes_RepeatedGroup>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestAllTypes_RepeatedGroup& from);
  void MergeFrom(const TestAllTypes_RepeatedGroup& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TestAllTypes_RepeatedGroup* other);
  protected:
  explicit TestAllTypes_RepeatedGroup(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional int32 a = 47;
  bool has_a() const;
  void clear_a();
  static const int kAFieldNumber = 47;
  ::google::protobuf::int32 a() const;
  void set_a(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestAllTypes.RepeatedGroup)
 private:
  void set_has_a();
  void clear_has_a();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::int32 a_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class TestAllTypes : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.TestAllTypes) */ {
 public:
  TestAllTypes();
  virtual ~TestAllTypes();

  TestAllTypes(const TestAllTypes& from);

  inline TestAllTypes& operator=(const TestAllTypes& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TestAllTypes(TestAllTypes&& from) noexcept
    : TestAllTypes() {
    *this = ::std::move(from);
  }

  inline TestAllTypes& operator=(TestAllTypes&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const TestAllTypes& default_instance();

  enum OneofFieldCase {
    kOneofUint32 = 111,
    kOneofNestedMessage = 112,
    kOneofString = 113,
    kOneofBytes = 114,
    ONEOF_FIELD_NOT_SET = 0,
  };

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TestAllTypes* internal_default_instance() {
    return reinterpret_cast<const TestAllTypes*>(
               &_TestAllTypes_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

  void UnsafeArenaSwap(TestAllTypes* other);
  void Swap(TestAllTypes* other);
  friend void swap(TestAllTypes& a, TestAllTypes& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline TestAllTypes* New() const final {
    return CreateMaybeMessage<TestAllTypes>(NULL);
  }

  TestAllTypes* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestAllTypes>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestAllTypes& from);
  void MergeFrom(const TestAllTypes& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TestAllTypes* other);
  protected:
  explicit TestAllTypes(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef TestAllTypes_NestedMessage NestedMessage;
  typedef TestAllTypes_OptionalGroup OptionalGroup;
  typedef TestAllTypes_RepeatedGroup RepeatedGroup;

  typedef TestAllTypes_NestedEnum NestedEnum;
  static const NestedEnum FOO =
    TestAllTypes_NestedEnum_FOO;
  static const NestedEnum BAR =
    TestAllTypes_NestedEnum_BAR;
  static const NestedEnum BAZ =
    TestAllTypes_NestedEnum_BAZ;
  static const NestedEnum NEG =
    TestAllTypes_NestedEnum_NEG;
  static inline bool NestedEnum_IsValid(int value) {
    return TestAllTypes_NestedEnum_IsValid(value);
  }
  static const NestedEnum NestedEnum_MIN =
    TestAllTypes_NestedEnum_NestedEnum_MIN;
  static const NestedEnum NestedEnum_MAX =
    TestAllTypes_NestedEnum_NestedEnum_MAX;
  static const int NestedEnum_ARRAYSIZE =
    TestAllTypes_NestedEnum_NestedEnum_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  NestedEnum_descriptor() {
    return TestAllTypes_NestedEnum_descriptor();
  }
  static inline const ::std::string& NestedEnum_Name(NestedEnum value) {
    return TestAllTypes_NestedEnum_Name(value);
  }
  static inline bool NestedEnum_Parse(const ::std::string& name,
      NestedEnum* value) {
    return TestAllTypes_NestedEnum_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  // repeated int32 repeated_int32 = 31;
  int repeated_int32_size() const;
  void clear_repeated_int32();
  static const int kRepeatedInt32FieldNumber = 31;
  ::google::protobuf::int32 repeated_int32(int index) const;
  void set_repeated_int32(int index, ::google::protobuf::int32 value);
  void add_repeated_int32(::google::protobuf::int32 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
      repeated_int32() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
      mutable_repeated_int32();

  // repeated int64 repeated_int64 = 32;
  int repeated_int64_size() const;
  void clear_repeated_int64();
  static const int kRepeatedInt64FieldNumber = 32;
  ::google::protobuf::int64 repeated_int64(int index) const;
  void set_repeated_int64(int index, ::google::protobuf::int64 value);
  void add_repeated_int64(::google::protobuf::int64 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
      repeated_int64() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
      mutable_repeated_int64();

  // repeated uint32 repeated_uint32 = 33;
  int repeated_uint32_size() const;
  void clear_repeated_uint32();
  static const int kRepeatedUint32FieldNumber = 33;
  ::google::protobuf::uint32 repeated_uint32(int index) const;
  void set_repeated_uint32(int index, ::google::protobuf::uint32 value);
  void add_repeated_uint32(::google::protobuf::uint32 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
      repeated_uint32() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
      mutable_repeated_uint32();

  // repeated uint64 repeated_uint64 = 34;
  int repeated_uint64_size() const;
  void clear_repeated_uint64();
  static const int kRepeatedUint64FieldNumber = 34;
  ::google::protobuf::uint64 repeated_uint64(int index) const;
  void set_repeated_uint64(int index, ::google::protobuf::uint64 value);
  void add_repeated_uint64(::google::protobuf::uint64 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >&
      repeated_uint64() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >*
      mutable_repeated_uint64();

  // repeated sint32 repeated_sint32 = 35;
  int repeated_sint32_size() const;
  void clear_repeated_sint32();
  static const int kRepeatedSint32FieldNumber = 35;
  ::google::protobuf::int32 repeated_sint32(int index) const;
  void set_repeated_sint32(int index, ::google::protobuf::int32 value);
  void add_repeated_sint32(::google::protobuf::int32 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
      repeated_sint32() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
      mutable_repeated_sint32();

  // repeated sint64 repeated_sint64 = 36;
  int repeated_sint64_size() const;
  void clear_repeated_sint64();
  static const int kRepeatedSint64FieldNumber = 36;
  ::google::protobuf::int64 repeated_sint64(int index) const;
  void set_repeated_sint64(int index, ::google::protobuf::int64 value);
  void add_repeated_sint64(::google::protobuf::int64 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
      repeated_sint64() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
      mutable_repeated_sint64();

  // repeated fixed32 repeated_fixed32 = 37;
  int repeated_fixed32_size() const;
  void clear_repeated_fixed32();
  static const int kRepeatedFixed32FieldNumber = 37;
  ::google::protobuf::uint32 repeated_fixed32(int index) const;
  void set_repeated_fixed32(int index, ::google::protobuf::uint32 value);
  void add_repeated_fixed32(::google::protobuf::uint32 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
      repeated_fixed32() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
      mutable_repeated_fixed32();

  // repeated fixed64 repeated_fixed64 = 38;
  int repeated_fixed64_size() const;
  void clear_repeated_fixed64();
  static const int kRepeatedFixed64FieldNumber = 38;
  ::google::protobuf::uint64 repeated_fixed64(int index) const;
  void set_repeated_fixed64(int index, ::google::protobuf::uint64 value);
  void add_repeated_fixed64(::google::protobuf::uint64 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >&
      repeated_fixed64() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >*
      mutable_repeated_fixed64();

  // repeated sfixed32 repeated_sfixed32 = 39;
  int repeated_sfixed32_size() const;
  void clear_repeated_sfixed32();
  static const int kRepeatedSfixed32FieldNumber = 39;
  ::google::protobuf::int32 repeated_sfixed32(int index) const;
  void set_repeated_sfixed32(int index, ::google::protobuf::int32 value);
  void add_repeated_sfixed32(::google::protobuf::int32 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
      repeated_sfixed32() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
      mutable_repeated_sfixed32();

  // repeated sfixed64 repeated_sfixed64 = 40;
  int repeated_sfixed64_size() const;
  void clear_repeated_sfixed64();
  static const int kRepeatedSfixed64FieldNumber = 40;
  ::google::protobuf::int64 repeated_sfixed64(int index) const;
  void set_repeated_sfixed64(int index, ::google::protobuf::int64 value);
  void add_repeated_sfixed64(::google::protobuf::int64 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
      repeated_sfixed64() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
      mutable_repeated_sfixed64();

  // repeated float repeated_float = 41;
  int repeated_float_size() const;
  void clear_repeated_float();
  static const int kRepeatedFloatFieldNumber = 41;
  float repeated_float(int index) const;
  void set_repeated_float(int index, float value);
  void add_repeated_float(float value);
  const ::google::protobuf::RepeatedField< float >&
      repeated_float() const;
  ::google::protobuf::RepeatedField< float >*
      mutable_repeated_float();

  // repeated double repeated_double = 42;
  int repeated_double_size() const;
  void clear_repeated_double();
  static const int kRepeatedDoubleFieldNumber = 42;
  double repeated_double(int index) const;
  void set_repeated_double(int index, double value);
  void add_repeated_double(double value);
  const ::google::protobuf::RepeatedField< double >&
      repeated_double() const;
  ::google::protobuf::RepeatedField< double >*
      mutable_repeated_double();

  // repeated bool repeated_bool = 43;
  int repeated_bool_size() const;
  void clear_repeated_bool();
  static const int kRepeatedBoolFieldNumber = 43;
  bool repeated_bool(int index) const;
  void set_repeated_bool(int index, bool value);
  void add_repeated_bool(bool value);
  const ::google::protobuf::RepeatedField< bool >&
      repeated_bool() const;
  ::google::protobuf::RepeatedField< bool >*
      mutable_repeated_bool();

  // repeated string repeated_string = 44;
  int repeated_string_size() const;
  void clear_repeated_string();
  static const int kRepeatedStringFieldNumber = 44;
  const ::std::string& repeated_string(int index) const;
  ::std::string* mutable_repeated_string(int index);
  void set_repeated_string(int index, const ::std::string& value);
  #if LANG_CXX11
  void set_repeated_string(int index, ::std::string&& value);
  #endif
  void set_repeated_string(int index, const char* value);
  void set_repeated_string(int index, const char* value, size_t size);
  ::std::string* add_repeated_string();
  void add_repeated_string(const ::std::string& value);
  #if LANG_CXX11
  void add_repeated_string(::std::string&& value);
  #endif
  void add_repeated_string(const char* value);
  void add_repeated_string(const char* value, size_t size);
  const ::google::protobuf::RepeatedPtrField< ::std::string>& repeated_string() const;
  ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_repeated_string();

  // repeated bytes repeated_bytes = 45;
  int repeated_bytes_size() const;
  void clear_repeated_bytes();
  static const int kRepeatedBytesFieldNumber = 45;
  const ::std::string& repeated_bytes(int index) const;
  ::std::string* mutable_repeated_bytes(int index);
  void set_repeated_bytes(int index, const ::std::string& value);
  #if LANG_CXX11
  void set_repeated_bytes(int index, ::std::string&& value);
  #endif
  void set_repeated_bytes(int index, const char* value);
  void set_repeated_bytes(int index, const void* value, size_t size);
  ::std::string* add_repeated_bytes();
  void add_repeated_bytes(const ::std::string& value);
  #if LANG_CXX11
  void add_repeated_bytes(::std::string&& value);
  #endif
  void add_repeated_bytes(const char* value);
  void add_repeated_bytes(const void* value, size_t size);
  const ::google::protobuf::RepeatedPtrField< ::std::string>& repeated_bytes() const;
  ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_repeated_bytes();

  // repeated group RepeatedGroup = 46 { ... };
  int repeatedgroup_size() const;
  void clear_repeatedgroup();
  static const int kRepeatedgroupFieldNumber = 46;
  ::protobuf_unittest::TestAllTypes_RepeatedGroup* mutable_repeatedgroup(int index);
  ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::TestAllTypes_RepeatedGroup >*
      mutable_repeatedgroup();
  const ::protobuf_unittest::TestAllTypes_RepeatedGroup& repeatedgroup(int index) const;
  ::protobuf_unittest::TestAllTypes_RepeatedGroup* add_repeatedgroup();
  const ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::TestAllTypes_RepeatedGroup >&
      repeatedgroup() const;

  // repeated .protobuf_unittest.TestAllTypes.NestedMessage repeated_nested_message = 48;
  int repeated_nested_message_size() const;
  void clear_repeated_nested_message();
  static const int kRepeatedNestedMessageFieldNumber = 48;
  ::protobuf_unittest::TestAllTypes_NestedMessage* mutable_repeated_nested_message(int index);
  ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::TestAllTypes_NestedMessage >*
      mutable_repeated_nested_message();
  const ::protobuf_unittest::TestAllTypes_NestedMessage& repeated_nested_message(int index) const;
  ::protobuf_unittest::TestAllTypes_NestedMessage* add_repeated_nested_message();
  const ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::TestAllTypes_NestedMessage >&
      repeated_nested_message() const;

  // repeated .protobuf_unittest.ForeignMessage repeated_foreign_message = 49;
  int repeated_foreign_message_size() const;
  void clear_repeated_foreign_message();
  static const int kRepeatedForeignMessageFieldNumber = 49;
  ::protobuf_unittest::ForeignMessage* mutable_repeated_foreign_message(int index);
  ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::ForeignMessage >*
      mutable_repeated_foreign_message();
  const ::protobuf_unittest::ForeignMessage& repeated_foreign_message(int index) const;
  ::protobuf_unittest::ForeignMessage* add_repeated_foreign_message();
  const ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::ForeignMessage >&
      repeated_foreign_message() const;

  // repeated .protobuf_unittest_import.ImportMessage repeated_import_message = 50;
  int repeated_import_message_size() const;
  void clear_repeated_import_message();
  static const int kRepeatedImportMessageFieldNumber = 50;
  ::protobuf_unittest_import::ImportMessage* mutable_repeated_import_message(int index);
  ::google::protobuf::RepeatedPtrField< ::protobuf_unittest_import::ImportMessage >*
      mutable_repeated_import_message();
  const ::protobuf_unittest_import::ImportMessage& repeated_import_message(int index) const;
  ::protobuf_unittest_import::ImportMessage* add_repeated_import_message();
  const ::google::protobuf::RepeatedPtrField< ::protobuf_unittest_import::ImportMessage >&
      repeated_import_message() const;

  // repeated .protobuf_unittest.TestAllTypes.NestedEnum repeated_nested_enum = 51;
  int repeated_nested_enum_size() const;
  void clear_repeated_nested_enum();
  static const int kRepeatedNestedEnumFieldNumber = 51;
  ::protobuf_unittest::TestAllTypes_NestedEnum repeated_nested_enum(int index) const;
  void set_repeated_nested_enum(int index, ::protobuf_unittest::TestAllTypes_NestedEnum value);
  void add_repeated_nested_enum(::protobuf_unittest::TestAllTypes_NestedEnum value);
  const ::google::protobuf::RepeatedField<int>& repeated_nested_enum() const;
  ::google::protobuf::RepeatedField<int>* mutable_repeated_nested_enum();

  // repeated .protobuf_unittest.ForeignEnum repeated_foreign_enum = 52;
  int repeated_foreign_enum_size() const;
  void clear_repeated_foreign_enum();
  static const int kRepeatedForeignEnumFieldNumber = 52;
  ::protobuf_unittest::ForeignEnum repeated_foreign_enum(int index) const;
  void set_repeated_foreign_enum(int index, ::protobuf_unittest::ForeignEnum value);
  void add_repeated_foreign_enum(::protobuf_unittest::ForeignEnum value);
  const ::google::protobuf::RepeatedField<int>& repeated_foreign_enum() const;
  ::google::protobuf::RepeatedField<int>* mutable_repeated_foreign_enum();

  // repeated .protobuf_unittest_import.ImportEnum repeated_import_enum = 53;
  int repeated_import_enum_size() const;
  void clear_repeated_import_enum();
  static const int kRepeatedImportEnumFieldNumber = 53;
  ::protobuf_unittest_import::ImportEnum repeated_import_enum(int index) const;
  void set_repeated_import_enum(int index, ::protobuf_unittest_import::ImportEnum value);
  void add_repeated_import_enum(::protobuf_unittest_import::ImportEnum value);
  const ::google::protobuf::RepeatedField<int>& repeated_import_enum() const;
  ::google::protobuf::RepeatedField<int>* mutable_repeated_import_enum();

  // repeated string repeated_string_piece = 54 [ctype = STRING_PIECE];
  int repeated_string_piece_size() const;
  void clear_repeated_string_piece();
  static const int kRepeatedStringPieceFieldNumber = 54;
 private:
  // Hidden due to unknown ctype option.
  const ::std::string& repeated_string_piece(int index) const;
  ::std::string* mutable_repeated_string_piece(int index);
  void set_repeated_string_piece(int index, const ::std::string& value);
  #if LANG_CXX11
  void set_repeated_string_piece(int index, ::std::string&& value);
  #endif
  void set_repeated_string_piece(int index, const char* value);
  void set_repeated_string_piece(int index, const char* value, size_t size);
  ::std::string* add_repeated_string_piece();
  void add_repeated_string_piece(const ::std::string& value);
  #if LANG_CXX11
  void add_repeated_string_piece(::std::string&& value);
  #endif
  void add_repeated_string_piece(const char* value);
  void add_repeated_string_piece(const char* value, size_t size);
  const ::google::protobuf::RepeatedPtrField< ::std::string>& repeated_string_piece() const;
  ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_repeated_string_piece();
 public:

  // repeated string repeated_cord = 55 [ctype = CORD];
  int repeated_cord_size() const;
  void clear_repeated_cord();
  static const int kRepeatedCordFieldNumber = 55;
 private:
  // Hidden due to unknown ctype option.
  const ::std::string& repeated_cord(int index) const;
  ::std::string* mutable_repeated_cord(int index);
  void set_repeated_cord(int index, const ::std::string& value);
  #if LANG_CXX11
  void set_repeated_cord(int index, ::std::string&& value);
  #endif
  void set_repeated_cord(int index, const char* value);
  void set_repeated_cord(int index, const char* value, size_t size);
  ::std::string* add_repeated_cord();
  void add_repeated_cord(const ::std::string& value);
  #if LANG_CXX11
  void add_repeated_cord(::std::string&& value);
  #endif
  void add_repeated_cord(const char* value);
  void add_repeated_cord(const char* value, size_t size);
  const ::google::protobuf::RepeatedPtrField< ::std::string>& repeated_cord() const;
  ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_repeated_cord();
 public:

  // repeated .protobuf_unittest.TestAllTypes.NestedMessage repeated_lazy_message = 57 [lazy = true];
  int repeated_lazy_message_size() const;
  void clear_repeated_lazy_message();
  static const int kRepeatedLazyMessageFieldNumber = 57;
  ::protobuf_unittest::TestAllTypes_NestedMessage* mutable_repeated_lazy_message(int index);
  ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::TestAllTypes_NestedMessage >*
      mutable_repeated_lazy_message();
  const ::protobuf_unittest::TestAllTypes_NestedMessage& repeated_lazy_message(int index) const;
  ::protobuf_unittest::TestAllTypes_NestedMessage* add_repeated_lazy_message();
  const ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::TestAllTypes_NestedMessage >&
      repeated_lazy_message() const;

  // optional string optional_string = 14;
  bool has_optional_string() const;
  void clear_optional_string();
  static const int kOptionalStringFieldNumber = 14;
  const ::std::string& optional_string() const;
  void set_optional_string(const ::std::string& value);
  #if LANG_CXX11
  void set_optional_string(::std::string&& value);
  #endif
  void set_optional_string(const char* value);
  void set_optional_string(const char* value, size_t size);
  ::std::string* mutable_optional_string();
  ::std::string* release_optional_string();
  void set_allocated_optional_string(::std::string* optional_string);
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  ::std::string* unsafe_arena_release_optional_string();
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  void unsafe_arena_set_allocated_optional_string(
      ::std::string* optional_string);

  // optional bytes optional_bytes = 15;
  bool has_optional_bytes() const;
  void clear_optional_bytes();
  static const int kOptionalBytesFieldNumber = 15;
  const ::std::string& optional_bytes() const;
  void set_optional_bytes(const ::std::string& value);
  #if LANG_CXX11
  void set_optional_bytes(::std::string&& value);
  #endif
  void set_optional_bytes(const char* value);
  void set_optional_bytes(const void* value, size_t size);
  ::std::string* mutable_optional_bytes();
  ::std::string* release_optional_bytes();
  void set_allocated_optional_bytes(::std::string* optional_bytes);
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  ::std::string* unsafe_arena_release_optional_bytes();
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  void unsafe_arena_set_allocated_optional_bytes(
      ::std::string* optional_bytes);

  // optional string optional_string_piece = 24 [ctype = STRING_PIECE];
  bool has_optional_string_piece() const;
  void clear_optional_string_piece();
  static const int kOptionalStringPieceFieldNumber = 24;
 private:
  // Hidden due to unknown ctype option.
  const ::std::string& optional_string_piece() const;
  void set_optional_string_piece(const ::std::string& value);
  #if LANG_CXX11
  void set_optional_string_piece(::std::string&& value);
  #endif
  void set_optional_string_piece(const char* value);
  void set_optional_string_piece(const char* value, size_t size);
  ::std::string* mutable_optional_string_piece();
  ::std::string* release_optional_string_piece();
  void set_allocated_optional_string_piece(::std::string* optional_string_piece);
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  ::std::string* unsafe_arena_release_optional_string_piece();
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  void unsafe_arena_set_allocated_optional_string_piece(
      ::std::string* optional_string_piece);
 public:

  // optional string optional_cord = 25 [ctype = CORD];
  bool has_optional_cord() const;
  void clear_optional_cord();
  static const int kOptionalCordFieldNumber = 25;
 private:
  // Hidden due to unknown ctype option.
  const ::std::string& optional_cord() const;
  void set_optional_cord(const ::std::string& value);
  #if LANG_CXX11
  void set_optional_cord(::std::string&& value);
  #endif
  void set_optional_cord(const char* value);
  void set_optional_cord(const char* value, size_t size);
  ::std::string* mutable_optional_cord();
  ::std::string* release_optional_cord();
  void set_allocated_optional_cord(::std::string* optional_cord);
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  ::std::string* unsafe_arena_release_optional_cord();
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  void unsafe_arena_set_allocated_optional_cord(
      ::std::string* optional_cord);
 public:

  // optional string default_string = 74 [default = "hello"];
  bool has_default_string() const;
  void clear_default_string();
  static const int kDefaultStringFieldNumber = 74;
  const ::std::string& default_string() const;
  void set_default_string(const ::std::string& value);
  #if LANG_CXX11
  void set_default_string(::std::string&& value);
  #endif
  void set_default_string(const char* value);
  void set_default_string(const char* value, size_t size);
  ::std::string* mutable_default_string();
  ::std::string* release_default_string();
  void set_allocated_default_string(::std::string* default_string);
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  ::std::string* unsafe_arena_release_default_string();
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  void unsafe_arena_set_allocated_default_string(
      ::std::string* default_string);

  // optional bytes default_bytes = 75 [default = "world"];
  bool has_default_bytes() const;
  void clear_default_bytes();
  static const int kDefaultBytesFieldNumber = 75;
  const ::std::string& default_bytes() const;
  void set_default_bytes(const ::std::string& value);
  #if LANG_CXX11
  void set_default_bytes(::std::string&& value);
  #endif
  void set_default_bytes(const char* value);
  void set_default_bytes(const void* value, size_t size);
  ::std::string* mutable_default_bytes();
  ::std::string* release_default_bytes();
  void set_allocated_default_bytes(::std::string* default_bytes);
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  ::std::string* unsafe_arena_release_default_bytes();
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  void unsafe_arena_set_allocated_default_bytes(
      ::std::string* default_bytes);

  // optional string default_string_piece = 84 [default = "abc", ctype = STRING_PIECE];
  bool has_default_string_piece() const;
  void clear_default_string_piece();
  static const int kDefaultStringPieceFieldNumber = 84;
 private:
  // Hidden due to unknown ctype option.
  const ::std::string& default_string_piece() const;
  void set_default_string_piece(const ::std::string& value);
  #if LANG_CXX11
  void set_default_string_piece(::std::string&& value);
  #endif
  void set_default_string_piece(const char* value);
  void set_default_string_piece(const char* value, size_t size);
  ::std::string* mutable_default_string_piece();
  ::std::string* release_default_string_piece();
  void set_allocated_default_string_piece(::std::string* default_string_piece);
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  ::std::string* unsafe_arena_release_default_string_piece();
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  void unsafe_arena_set_allocated_default_string_piece(
      ::std::string* default_string_piece);
 public:

  // optional string default_cord = 85 [default = "123", ctype = CORD];
  bool has_default_cord() const;
  void clear_default_cord();
  static const int kDefaultCordFieldNumber = 85;
 private:
  // Hidden due to unknown ctype option.
  const ::std::string& default_cord() const;
  void set_default_cord(const ::std::string& value);
  #if LANG_CXX11
  void set_default_cord(::std::string&& value);
  #endif
  void set_default_cord(const char* value);
  void set_default_cord(const char* value, size_t size);
  ::std::string* mutable_default_cord();
  ::std::string* release_default_cord();
  void set_allocated_default_cord(::std::string* default_cord);
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  ::std::string* unsafe_arena_release_default_cord();
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  void unsafe_arena_set_allocated_default_cord(
      ::std::string* default_cord);
 public:

  // optional group OptionalGroup = 16 { ... };
  bool has_optionalgroup() const;
  void clear_optionalgroup();
  static const int kOptionalgroupFieldNumber = 16;
  private:
  const ::protobuf_unittest::TestAllTypes_OptionalGroup& _internal_optionalgroup() const;
  public:
  const ::protobuf_unittest::TestAllTypes_OptionalGroup& optionalgroup() const;
  ::protobuf_unittest::TestAllTypes_OptionalGroup* release_optionalgroup();
  ::protobuf_unittest::TestAllTypes_OptionalGroup* mutable_optionalgroup();
  void set_allocated_optionalgroup(::protobuf_unittest::TestAllTypes_OptionalGroup* optionalgroup);
  void unsafe_arena_set_allocated_optionalgroup(
      ::protobuf_unittest::TestAllTypes_OptionalGroup* optionalgroup);
  ::protobuf_unittest::TestAllTypes_OptionalGroup* unsafe_arena_release_optionalgroup();

  // optional .protobuf_unittest.TestAllTypes.NestedMessage optional_nested_message = 18;
  bool has_optional_nested_message() const;
  void clear_optional_nested_message();
  static const int kOptionalNestedMessageFieldNumber = 18;
  private:
  const ::protobuf_unittest::TestAllTypes_NestedMessage& _internal_optional_nested_message() const;
  public:
  const ::protobuf_unittest::TestAllTypes_NestedMessage& optional_nested_message() const;
  ::protobuf_unittest::TestAllTypes_NestedMessage* release_optional_nested_message();
  ::protobuf_unittest::TestAllTypes_NestedMessage* mutable_optional_nested_message();
  void set_allocated_optional_nested_message(::protobuf_unittest::TestAllTypes_NestedMessage* optional_nested_message);
  void unsafe_arena_set_allocated_optional_nested_message(
      ::protobuf_unittest::TestAllTypes_NestedMessage* optional_nested_message);
  ::protobuf_unittest::TestAllTypes_NestedMessage* unsafe_arena_release_optional_nested_message();

  // optional .protobuf_unittest.ForeignMessage optional_foreign_message = 19;
  bool has_optional_foreign_message() const;
  void clear_optional_foreign_message();
  static const int kOptionalForeignMessageFieldNumber = 19;
  private:
  const ::protobuf_unittest::ForeignMessage& _internal_optional_foreign_message() const;
  public:
  const ::protobuf_unittest::ForeignMessage& optional_foreign_message() const;
  ::protobuf_unittest::ForeignMessage* release_optional_foreign_message();
  ::protobuf_unittest::ForeignMessage* mutable_optional_foreign_message();
  void set_allocated_optional_foreign_message(::protobuf_unittest::ForeignMessage* optional_foreign_message);
  void unsafe_arena_set_allocated_optional_foreign_message(
      ::protobuf_unittest::ForeignMessage* optional_foreign_message);
  ::protobuf_unittest::ForeignMessage* unsafe_arena_release_optional_foreign_message();

  // optional .protobuf_unittest_import.ImportMessage optional_import_message = 20;
  bool has_optional_import_message() const;
  void clear_optional_import_message();
  static const int kOptionalImportMessageFieldNumber = 20;
  private:
  const ::protobuf_unittest_import::ImportMessage& _internal_optional_import_message() const;
  public:
  const ::protobuf_unittest_import::ImportMessage& optional_import_message() const;
  ::protobuf_unittest_import::ImportMessage* release_optional_import_message();
  ::protobuf_unittest_import::ImportMessage* mutable_optional_import_message();
  void set_allocated_optional_import_message(::protobuf_unittest_import::ImportMessage* optional_import_message);
  void unsafe_arena_set_allocated_optional_import_message(
      ::protobuf_unittest_import::ImportMessage* optional_import_message);
  ::protobuf_unittest_import::ImportMessage* unsafe_arena_release_optional_import_message();

  // optional .protobuf_unittest_import.PublicImportMessage optional_public_import_message = 26;
  bool has_optional_public_import_message() const;
  void clear_optional_public_import_message();
  static const int kOptionalPublicImportMessageFieldNumber = 26;
  private:
  const ::protobuf_unittest_import::PublicImportMessage& _internal_optional_public_import_message() const;
  public:
  const ::protobuf_unittest_import::PublicImportMessage& optional_public_import_message() const;
  ::protobuf_unittest_import::PublicImportMessage* release_optional_public_import_message();
  ::protobuf_unittest_import::PublicImportMessage* mutable_optional_public_import_message();
  void set_allocated_optional_public_import_message(::protobuf_unittest_import::PublicImportMessage* optional_public_import_message);
  void unsafe_arena_set_allocated_optional_public_import_message(
      ::protobuf_unittest_import::PublicImportMessage* optional_public_import_message);
  ::protobuf_unittest_import::PublicImportMessage* unsafe_arena_release_optional_public_import_message();

  // optional .protobuf_unittest.TestAllTypes.NestedMessage optional_lazy_message = 27 [lazy = true];
  bool has_optional_lazy_message() const;
  void clear_optional_lazy_message();
  static const int kOptionalLazyMessageFieldNumber = 27;
  private:
  const ::protobuf_unittest::TestAllTypes_NestedMessage& _internal_optional_lazy_message() const;
  public:
  const ::protobuf_unittest::TestAllTypes_NestedMessage& optional_lazy_message() const;
  ::protobuf_unittest::TestAllTypes_NestedMessage* release_optional_lazy_message();
  ::protobuf_unittest::TestAllTypes_NestedMessage* mutable_optional_lazy_message();
  void set_allocated_optional_lazy_message(::protobuf_unittest::TestAllTypes_NestedMessage* optional_lazy_message);
  void unsafe_arena_set_allocated_optional_lazy_message(
      ::protobuf_unittest::TestAllTypes_NestedMessage* optional_lazy_message);
  ::protobuf_unittest::TestAllTypes_NestedMessage* unsafe_arena_release_optional_lazy_message();

  // optional int64 optional_int64 = 2;
  bool has_optional_int64() const;
  void clear_optional_int64();
  static const int kOptionalInt64FieldNumber = 2;
  ::google::protobuf::int64 optional_int64() const;
  void set_optional_int64(::google::protobuf::int64 value);

  // optional int32 optional_int32 = 1;
  bool has_optional_int32() const;
  void clear_optional_int32();
  static const int kOptionalInt32FieldNumber = 1;
  ::google::protobuf::int32 optional_int32() const;
  void set_optional_int32(::google::protobuf::int32 value);

  // optional uint32 optional_uint32 = 3;
  bool has_optional_uint32() const;
  void clear_optional_uint32();
  static const int kOptionalUint32FieldNumber = 3;
  ::google::protobuf::uint32 optional_uint32() const;
  void set_optional_uint32(::google::protobuf::uint32 value);

  // optional uint64 optional_uint64 = 4;
  bool has_optional_uint64() const;
  void clear_optional_uint64();
  static const int kOptionalUint64FieldNumber = 4;
  ::google::protobuf::uint64 optional_uint64() const;
  void set_optional_uint64(::google::protobuf::uint64 value);

  // optional sint64 optional_sint64 = 6;
  bool has_optional_sint64() const;
  void clear_optional_sint64();
  static const int kOptionalSint64FieldNumber = 6;
  ::google::protobuf::int64 optional_sint64() const;
  void set_optional_sint64(::google::protobuf::int64 value);

  // optional sint32 optional_sint32 = 5;
  bool has_optional_sint32() const;
  void clear_optional_sint32();
  static const int kOptionalSint32FieldNumber = 5;
  ::google::protobuf::int32 optional_sint32() const;
  void set_optional_sint32(::google::protobuf::int32 value);

  // optional fixed32 optional_fixed32 = 7;
  bool has_optional_fixed32() const;
  void clear_optional_fixed32();
  static const int kOptionalFixed32FieldNumber = 7;
  ::google::protobuf::uint32 optional_fixed32() const;
  void set_optional_fixed32(::google::protobuf::uint32 value);

  // optional fixed64 optional_fixed64 = 8;
  bool has_optional_fixed64() const;
  void clear_optional_fixed64();
  static const int kOptionalFixed64FieldNumber = 8;
  ::google::protobuf::uint64 optional_fixed64() const;
  void set_optional_fixed64(::google::protobuf::uint64 value);

  // optional sfixed64 optional_sfixed64 = 10;
  bool has_optional_sfixed64() const;
  void clear_optional_sfixed64();
  static const int kOptionalSfixed64FieldNumber = 10;
  ::google::protobuf::int64 optional_sfixed64() const;
  void set_optional_sfixed64(::google::protobuf::int64 value);

  // optional sfixed32 optional_sfixed32 = 9;
  bool has_optional_sfixed32() const;
  void clear_optional_sfixed32();
  static const int kOptionalSfixed32FieldNumber = 9;
  ::google::protobuf::int32 optional_sfixed32() const;
  void set_optional_sfixed32(::google::protobuf::int32 value);

  // optional float optional_float = 11;
  bool has_optional_float() const;
  void clear_optional_float();
  static const int kOptionalFloatFieldNumber = 11;
  float optional_float() const;
  void set_optional_float(float value);

  // optional double optional_double = 12;
  bool has_optional_double() const;
  void clear_optional_double();
  static const int kOptionalDoubleFieldNumber = 12;
  double optional_double() const;
  void set_optional_double(double value);

  // optional bool optional_bool = 13;
  bool has_optional_bool() const;
  void clear_optional_bool();
  static const int kOptionalBoolFieldNumber = 13;
  bool optional_bool() const;
  void set_optional_bool(bool value);

  // optional .protobuf_unittest_import.ImportEnum default_import_enum = 83 [default = IMPORT_BAR];
  bool has_default_import_enum() const;
  void clear_default_import_enum();
  static const int kDefaultImportEnumFieldNumber = 83;
  ::protobuf_unittest_import::ImportEnum default_import_enum() const;
  void set_default_import_enum(::protobuf_unittest_import::ImportEnum value);

  // optional .protobuf_unittest.TestAllTypes.NestedEnum optional_nested_enum = 21;
  bool has_optional_nested_enum() const;
  void clear_optional_nested_enum();
  static const int kOptionalNestedEnumFieldNumber = 21;
  ::protobuf_unittest::TestAllTypes_NestedEnum optional_nested_enum() const;
  void set_optional_nested_enum(::protobuf_unittest::TestAllTypes_NestedEnum value);

  // optional .protobuf_unittest.ForeignEnum optional_foreign_enum = 22;
  bool has_optional_foreign_enum() const;
  void clear_optional_foreign_enum();
  static const int kOptionalForeignEnumFieldNumber = 22;
  ::protobuf_unittest::ForeignEnum optional_foreign_enum() const;
  void set_optional_foreign_enum(::protobuf_unittest::ForeignEnum value);

  // optional .protobuf_unittest_import.ImportEnum optional_import_enum = 23;
  bool has_optional_import_enum() const;
  void clear_optional_import_enum();
  static const int kOptionalImportEnumFieldNumber = 23;
  ::protobuf_unittest_import::ImportEnum optional_import_enum() const;
  void set_optional_import_enum(::protobuf_unittest_import::ImportEnum value);

  // optional int32 default_int32 = 61 [default = 41];
  bool has_default_int32() const;
  void clear_default_int32();
  static const int kDefaultInt32FieldNumber = 61;
  ::google::protobuf::int32 default_int32() const;
  void set_default_int32(::google::protobuf::int32 value);

  // optional int64 default_int64 = 62 [default = 42];
  bool has_default_int64() const;
  void clear_default_int64();
  static const int kDefaultInt64FieldNumber = 62;
  ::google::protobuf::int64 default_int64() const;
  void set_default_int64(::google::protobuf::int64 value);

  // optional uint64 default_uint64 = 64 [default = 44];
  bool has_default_uint64() const;
  void clear_default_uint64();
  static const int kDefaultUint64FieldNumber = 64;
  ::google::protobuf::uint64 default_uint64() const;
  void set_default_uint64(::google::protobuf::uint64 value);

  // optional uint32 default_uint32 = 63 [default = 43];
  bool has_default_uint32() const;
  void clear_default_uint32();
  static const int kDefaultUint32FieldNumber = 63;
  ::google::protobuf::uint32 default_uint32() const;
  void set_default_uint32(::google::protobuf::uint32 value);

  // optional sint32 default_sint32 = 65 [default = -45];
  bool has_default_sint32() const;
  void clear_default_sint32();
  static const int kDefaultSint32FieldNumber = 65;
  ::google::protobuf::int32 default_sint32() const;
  void set_default_sint32(::google::protobuf::int32 value);

  // optional sint64 default_sint64 = 66 [default = 46];
  bool has_default_sint64() const;
  void clear_default_sint64();
  static const int kDefaultSint64FieldNumber = 66;
  ::google::protobuf::int64 default_sint64() const;
  void set_default_sint64(::google::protobuf::int64 value);

  // optional fixed64 default_fixed64 = 68 [default = 48];
  bool has_default_fixed64() const;
  void clear_default_fixed64();
  static const int kDefaultFixed64FieldNumber = 68;
  ::google::protobuf::uint64 default_fixed64() const;
  void set_default_fixed64(::google::protobuf::uint64 value);

  // optional fixed32 default_fixed32 = 67 [default = 47];
  bool has_default_fixed32() const;
  void clear_default_fixed32();
  static const int kDefaultFixed32FieldNumber = 67;
  ::google::protobuf::uint32 default_fixed32() const;
  void set_default_fixed32(::google::protobuf::uint32 value);

  // optional sfixed32 default_sfixed32 = 69 [default = 49];
  bool has_default_sfixed32() const;
  void clear_default_sfixed32();
  static const int kDefaultSfixed32FieldNumber = 69;
  ::google::protobuf::int32 default_sfixed32() const;
  void set_default_sfixed32(::google::protobuf::int32 value);

  // optional sfixed64 default_sfixed64 = 70 [default = -50];
  bool has_default_sfixed64() const;
  void clear_default_sfixed64();
  static const int kDefaultSfixed64FieldNumber = 70;
  ::google::protobuf::int64 default_sfixed64() const;
  void set_default_sfixed64(::google::protobuf::int64 value);

  // optional double default_double = 72 [default = 52000];
  bool has_default_double() const;
  void clear_default_double();
  static const int kDefaultDoubleFieldNumber = 72;
  double default_double() const;
  void set_default_double(double value);

  // optional float default_float = 71 [default = 51.5];
  bool has_default_float() const;
  void clear_default_float();
  static const int kDefaultFloatFieldNumber = 71;
  float default_float() const;
  void set_default_float(float value);

  // optional bool default_bool = 73 [default = true];
  bool has_default_bool() const;
  void clear_default_bool();
  static const int kDefaultBoolFieldNumber = 73;
  bool default_bool() const;
  void set_default_bool(bool value);

  // optional .protobuf_unittest.TestAllTypes.NestedEnum default_nested_enum = 81 [default = BAR];
  bool has_default_nested_enum() const;
  void clear_default_nested_enum();
  static const int kDefaultNestedEnumFieldNumber = 81;
  ::protobuf_unittest::TestAllTypes_NestedEnum default_nested_enum() const;
  void set_default_nested_enum(::protobuf_unittest::TestAllTypes_NestedEnum value);

  // optional .protobuf_unittest.ForeignEnum default_foreign_enum = 82 [default = FOREIGN_BAR];
  bool has_default_foreign_enum() const;
  void clear_default_foreign_enum();
  static const int kDefaultForeignEnumFieldNumber = 82;
  ::protobuf_unittest::ForeignEnum default_foreign_enum() const;
  void set_default_foreign_enum(::protobuf_unittest::ForeignEnum value);

  // optional uint32 oneof_uint32 = 111;
  bool has_oneof_uint32() const;
  void clear_oneof_uint32();
  static const int kOneofUint32FieldNumber = 111;
  ::google::protobuf::uint32 oneof_uint32() const;
  void set_oneof_uint32(::google::protobuf::uint32 value);

  // optional .protobuf_unittest.TestAllTypes.NestedMessage oneof_nested_message = 112;
  bool has_oneof_nested_message() const;
  void clear_oneof_nested_message();
  static const int kOneofNestedMessageFieldNumber = 112;
  private:
  const ::protobuf_unittest::TestAllTypes_NestedMessage& _internal_oneof_nested_message() const;
  public:
  const ::protobuf_unittest::TestAllTypes_NestedMessage& oneof_nested_message() const;
  ::protobuf_unittest::TestAllTypes_NestedMessage* release_oneof_nested_message();
  ::protobuf_unittest::TestAllTypes_NestedMessage* mutable_oneof_nested_message();
  void set_allocated_oneof_nested_message(::protobuf_unittest::TestAllTypes_NestedMessage* oneof_nested_message);
  void unsafe_arena_set_allocated_oneof_nested_message(
      ::protobuf_unittest::TestAllTypes_NestedMessage* oneof_nested_message);
  ::protobuf_unittest::TestAllTypes_NestedMessage* unsafe_arena_release_oneof_nested_message();

  // optional string oneof_string = 113;
  bool has_oneof_string() const;
  void clear_oneof_string();
  static const int kOneofStringFieldNumber = 113;
  const ::std::string& oneof_string() const;
  void set_oneof_string(const ::std::string& value);
  #if LANG_CXX11
  void set_oneof_string(::std::string&& value);
  #endif
  void set_oneof_string(const char* value);
  void set_oneof_string(const char* value, size_t size);
  ::std::string* mutable_oneof_string();
  ::std::string* release_oneof_string();
  void set_allocated_oneof_string(::std::string* oneof_string);
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  ::std::string* unsafe_arena_release_oneof_string();
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  void unsafe_arena_set_allocated_oneof_string(
      ::std::string* oneof_string);

  // optional bytes oneof_bytes = 114;
  bool has_oneof_bytes() const;
  void clear_oneof_bytes();
  static const int kOneofBytesFieldNumber = 114;
  const ::std::string& oneof_bytes() const;
  void set_oneof_bytes(const ::std::string& value);
  #if LANG_CXX11
  void set_oneof_bytes(::std::string&& value);
  #endif
  void set_oneof_bytes(const char* value);
  void set_oneof_bytes(const void* value, size_t size);
  ::std::string* mutable_oneof_bytes();
  ::std::string* release_oneof_bytes();
  void set_allocated_oneof_bytes(::std::string* oneof_bytes);
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  ::std::string* unsafe_arena_release_oneof_bytes();
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  void unsafe_arena_set_allocated_oneof_bytes(
      ::std::string* oneof_bytes);

  void clear_oneof_field();
  OneofFieldCase oneof_field_case() const;
  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestAllTypes)
 private:
  void set_has_optional_int32();
  void clear_has_optional_int32();
  void set_has_optional_int64();
  void clear_has_optional_int64();
  void set_has_optional_uint32();
  void clear_has_optional_uint32();
  void set_has_optional_uint64();
  void clear_has_optional_uint64();
  void set_has_optional_sint32();
  void clear_has_optional_sint32();
  void set_has_optional_sint64();
  void clear_has_optional_sint64();
  void set_has_optional_fixed32();
  void clear_has_optional_fixed32();
  void set_has_optional_fixed64();
  void clear_has_optional_fixed64();
  void set_has_optional_sfixed32();
  void clear_has_optional_sfixed32();
  void set_has_optional_sfixed64();
  void clear_has_optional_sfixed64();
  void set_has_optional_float();
  void clear_has_optional_float();
  void set_has_optional_double();
  void clear_has_optional_double();
  void set_has_optional_bool();
  void clear_has_optional_bool();
  void set_has_optional_string();
  void clear_has_optional_string();
  void set_has_optional_bytes();
  void clear_has_optional_bytes();
  void set_has_optionalgroup();
  void clear_has_optionalgroup();
  void set_has_optional_nested_message();
  void clear_has_optional_nested_message();
  void set_has_optional_foreign_message();
  void clear_has_optional_foreign_message();
  void set_has_optional_import_message();
  void clear_has_optional_import_message();
  void set_has_optional_nested_enum();
  void clear_has_optional_nested_enum();
  void set_has_optional_foreign_enum();
  void clear_has_optional_foreign_enum();
  void set_has_optional_import_enum();
  void clear_has_optional_import_enum();
  void set_has_optional_string_piece();
  void clear_has_optional_string_piece();
  void set_has_optional_cord();
  void clear_has_optional_cord();
  void set_has_optional_public_import_message();
  void clear_has_optional_public_import_message();
  void set_has_optional_lazy_message();
  void clear_has_optional_lazy_message();
  void set_has_default_int32();
  void clear_has_default_int32();
  void set_has_default_int64();
  void clear_has_default_int64();
  void set_has_default_uint32();
  void clear_has_default_uint32();
  void set_has_default_uint64();
  void clear_has_default_uint64();
  void set_has_default_sint32();
  void clear_has_default_sint32();
  void set_has_default_sint64();
  void clear_has_default_sint64();
  void set_has_default_fixed32();
  void clear_has_default_fixed32();
  void set_has_default_fixed64();
  void clear_has_default_fixed64();
  void set_has_default_sfixed32();
  void clear_has_default_sfixed32();
  void set_has_default_sfixed64();
  void clear_has_default_sfixed64();
  void set_has_default_float();
  void clear_has_default_float();
  void set_has_default_double();
  void clear_has_default_double();
  void set_has_default_bool();
  void clear_has_default_bool();
  void set_has_default_string();
  void clear_has_default_string();
  void set_has_default_bytes();
  void clear_has_default_bytes();
  void set_has_default_nested_enum();
  void clear_has_default_nested_enum();
  void set_has_default_foreign_enum();
  void clear_has_default_foreign_enum();
  void set_has_default_import_enum();
  void clear_has_default_import_enum();
  void set_has_default_string_piece();
  void clear_has_default_string_piece();
  void set_has_default_cord();
  void clear_has_default_cord();
  void set_has_oneof_uint32();
  void set_has_oneof_nested_message();
  void set_has_oneof_string();
  void set_has_oneof_bytes();

  inline bool has_oneof_field() const;
  inline void clear_has_oneof_field();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<2> _has_bits_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > repeated_int32_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int64 > repeated_int64_;
  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > repeated_uint32_;
  ::google::protobuf::RepeatedField< ::google::protobuf::uint64 > repeated_uint64_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > repeated_sint32_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int64 > repeated_sint64_;
  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > repeated_fixed32_;
  ::google::protobuf::RepeatedField< ::google::protobuf::uint64 > repeated_fixed64_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > repeated_sfixed32_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int64 > repeated_sfixed64_;
  ::google::protobuf::RepeatedField< float > repeated_float_;
  ::google::protobuf::RepeatedField< double > repeated_double_;
  ::google::protobuf::RepeatedField< bool > repeated_bool_;
  ::google::protobuf::RepeatedPtrField< ::std::string> repeated_string_;
  ::google::protobuf::RepeatedPtrField< ::std::string> repeated_bytes_;
  ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::TestAllTypes_RepeatedGroup > repeatedgroup_;
  ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::TestAllTypes_NestedMessage > repeated_nested_message_;
  ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::ForeignMessage > repeated_foreign_message_;
  ::google::protobuf::RepeatedPtrField< ::protobuf_unittest_import::ImportMessage > repeated_import_message_;
  ::google::protobuf::RepeatedField<int> repeated_nested_enum_;
  ::google::protobuf::RepeatedField<int> repeated_foreign_enum_;
  ::google::protobuf::RepeatedField<int> repeated_import_enum_;
  ::google::protobuf::RepeatedPtrField< ::std::string> repeated_string_piece_;
  ::google::protobuf::RepeatedPtrField< ::std::string> repeated_cord_;
  ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::TestAllTypes_NestedMessage > repeated_lazy_message_;
  ::google::protobuf::internal::ArenaStringPtr optional_string_;
  ::google::protobuf::internal::ArenaStringPtr optional_bytes_;
  ::google::protobuf::internal::ArenaStringPtr optional_string_piece_;
  ::google::protobuf::internal::ArenaStringPtr optional_cord_;
  public:
  static ::google::protobuf::internal::ExplicitlyConstructed< ::std::string> _i_give_permission_to_break_this_code_default_default_string_;
  private:
  ::google::protobuf::internal::ArenaStringPtr default_string_;
  public:
  static ::google::protobuf::internal::ExplicitlyConstructed< ::std::string> _i_give_permission_to_break_this_code_default_default_bytes_;
  private:
  ::google::protobuf::internal::ArenaStringPtr default_bytes_;
  public:
  static ::google::protobuf::internal::ExplicitlyConstructed< ::std::string> _i_give_permission_to_break_this_code_default_default_string_piece_;
  private:
  ::google::protobuf::internal::ArenaStringPtr default_string_piece_;
  public:
  static ::google::protobuf::internal::ExplicitlyConstructed< ::std::string> _i_give_permission_to_break_this_code_default_default_cord_;
  private:
  ::google::protobuf::internal::ArenaStringPtr default_cord_;
  ::protobuf_unittest::TestAllTypes_OptionalGroup* optionalgroup_;
  ::protobuf_unittest::TestAllTypes_NestedMessage* optional_nested_message_;
  ::protobuf_unittest::ForeignMessage* optional_foreign_message_;
  ::protobuf_unittest_import::ImportMessage* optional_import_message_;
  ::protobuf_unittest_import::PublicImportMessage* optional_public_import_message_;
  ::protobuf_unittest::TestAllTypes_NestedMessage* optional_lazy_message_;
  ::google::protobuf::int64 optional_int64_;
  ::google::protobuf::int32 optional_int32_;
  ::google::protobuf::uint32 optional_uint32_;
  ::google::protobuf::uint64 optional_uint64_;
  ::google::protobuf::int64 optional_sint64_;
  ::google::protobuf::int32 optional_sint32_;
  ::google::protobuf::uint32 optional_fixed32_;
  ::google::protobuf::uint64 optional_fixed64_;
  ::google::protobuf::int64 optional_sfixed64_;
  ::google::protobuf::int32 optional_sfixed32_;
  float optional_float_;
  double optional_double_;
  bool optional_bool_;
  int default_import_enum_;
  int optional_nested_enum_;
  int optional_foreign_enum_;
  int optional_import_enum_;
  ::google::protobuf::int32 default_int32_;
  ::google::protobuf::int64 default_int64_;
  ::google::protobuf::uint64 default_uint64_;
  ::google::protobuf::uint32 default_uint32_;
  ::google::protobuf::int32 default_sint32_;
  ::google::protobuf::int64 default_sint64_;
  ::google::protobuf::uint64 default_fixed64_;
  ::google::protobuf::uint32 default_fixed32_;
  ::google::protobuf::int32 default_sfixed32_;
  ::google::protobuf::int64 default_sfixed64_;
  double default_double_;
  float default_float_;
  bool default_bool_;
  int default_nested_enum_;
  int default_foreign_enum_;
  union OneofFieldUnion {
    OneofFieldUnion() {}
    ::google::protobuf::uint32 oneof_uint32_;
    ::protobuf_unittest::TestAllTypes_NestedMessage* oneof_nested_message_;
    ::google::protobuf::internal::ArenaStringPtr oneof_string_;
    ::google::protobuf::internal::ArenaStringPtr oneof_bytes_;
  } oneof_field_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::uint32 _oneof_case_[1];

  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class NestedTestAllTypes : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.NestedTestAllTypes) */ {
 public:
  NestedTestAllTypes();
  virtual ~NestedTestAllTypes();

  NestedTestAllTypes(const NestedTestAllTypes& from);

  inline NestedTestAllTypes& operator=(const NestedTestAllTypes& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  NestedTestAllTypes(NestedTestAllTypes&& from) noexcept
    : NestedTestAllTypes() {
    *this = ::std::move(from);
  }

  inline NestedTestAllTypes& operator=(NestedTestAllTypes&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const NestedTestAllTypes& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const NestedTestAllTypes* internal_default_instance() {
    return reinterpret_cast<const NestedTestAllTypes*>(
               &_NestedTestAllTypes_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

  void UnsafeArenaSwap(NestedTestAllTypes* other);
  void Swap(NestedTestAllTypes* other);
  friend void swap(NestedTestAllTypes& a, NestedTestAllTypes& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline NestedTestAllTypes* New() const final {
    return CreateMaybeMessage<NestedTestAllTypes>(NULL);
  }

  NestedTestAllTypes* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<NestedTestAllTypes>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const NestedTestAllTypes& from);
  void MergeFrom(const NestedTestAllTypes& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(NestedTestAllTypes* other);
  protected:
  explicit NestedTestAllTypes(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated .protobuf_unittest.NestedTestAllTypes repeated_child = 3;
  int repeated_child_size() const;
  void clear_repeated_child();
  static const int kRepeatedChildFieldNumber = 3;
  ::protobuf_unittest::NestedTestAllTypes* mutable_repeated_child(int index);
  ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::NestedTestAllTypes >*
      mutable_repeated_child();
  const ::protobuf_unittest::NestedTestAllTypes& repeated_child(int index) const;
  ::protobuf_unittest::NestedTestAllTypes* add_repeated_child();
  const ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::NestedTestAllTypes >&
      repeated_child() const;

  // optional .protobuf_unittest.NestedTestAllTypes child = 1;
  bool has_child() const;
  void clear_child();
  static const int kChildFieldNumber = 1;
  private:
  const ::protobuf_unittest::NestedTestAllTypes& _internal_child() const;
  public:
  const ::protobuf_unittest::NestedTestAllTypes& child() const;
  ::protobuf_unittest::NestedTestAllTypes* release_child();
  ::protobuf_unittest::NestedTestAllTypes* mutable_child();
  void set_allocated_child(::protobuf_unittest::NestedTestAllTypes* child);
  void unsafe_arena_set_allocated_child(
      ::protobuf_unittest::NestedTestAllTypes* child);
  ::protobuf_unittest::NestedTestAllTypes* unsafe_arena_release_child();

  // optional .protobuf_unittest.TestAllTypes payload = 2;
  bool has_payload() const;
  void clear_payload();
  static const int kPayloadFieldNumber = 2;
  private:
  const ::protobuf_unittest::TestAllTypes& _internal_payload() const;
  public:
  const ::protobuf_unittest::TestAllTypes& payload() const;
  ::protobuf_unittest::TestAllTypes* release_payload();
  ::protobuf_unittest::TestAllTypes* mutable_payload();
  void set_allocated_payload(::protobuf_unittest::TestAllTypes* payload);
  void unsafe_arena_set_allocated_payload(
      ::protobuf_unittest::TestAllTypes* payload);
  ::protobuf_unittest::TestAllTypes* unsafe_arena_release_payload();

  // @@protoc_insertion_point(class_scope:protobuf_unittest.NestedTestAllTypes)
 private:
  void set_has_child();
  void clear_has_child();
  void set_has_payload();
  void clear_has_payload();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::NestedTestAllTypes > repeated_child_;
  ::protobuf_unittest::NestedTestAllTypes* child_;
  ::protobuf_unittest::TestAllTypes* payload_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class TestDeprecatedFields : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.TestDeprecatedFields) */ {
 public:
  TestDeprecatedFields();
  virtual ~TestDeprecatedFields();

  TestDeprecatedFields(const TestDeprecatedFields& from);

  inline TestDeprecatedFields& operator=(const TestDeprecatedFields& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TestDeprecatedFields(TestDeprecatedFields&& from) noexcept
    : TestDeprecatedFields() {
    *this = ::std::move(from);
  }

  inline TestDeprecatedFields& operator=(TestDeprecatedFields&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const TestDeprecatedFields& default_instance();

  enum OneofFieldsCase {
    kDeprecatedInt32InOneof = 2,
    ONEOF_FIELDS_NOT_SET = 0,
  };

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TestDeprecatedFields* internal_default_instance() {
    return reinterpret_cast<const TestDeprecatedFields*>(
               &_TestDeprecatedFields_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;

  void UnsafeArenaSwap(TestDeprecatedFields* other);
  void Swap(TestDeprecatedFields* other);
  friend void swap(TestDeprecatedFields& a, TestDeprecatedFields& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline TestDeprecatedFields* New() const final {
    return CreateMaybeMessage<TestDeprecatedFields>(NULL);
  }

  TestDeprecatedFields* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestDeprecatedFields>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestDeprecatedFields& from);
  void MergeFrom(const TestDeprecatedFields& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TestDeprecatedFields* other);
  protected:
  explicit TestDeprecatedFields(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional int32 deprecated_int32 = 1 [deprecated = true];
  GOOGLE_PROTOBUF_DEPRECATED_ATTR bool has_deprecated_int32() const;
  GOOGLE_PROTOBUF_DEPRECATED_ATTR void clear_deprecated_int32();
  GOOGLE_PROTOBUF_DEPRECATED_ATTR static const int kDeprecatedInt32FieldNumber = 1;
  GOOGLE_PROTOBUF_DEPRECATED_ATTR ::google::protobuf::int32 deprecated_int32() const;
  GOOGLE_PROTOBUF_DEPRECATED_ATTR void set_deprecated_int32(::google::protobuf::int32 value);

  // optional int32 deprecated_int32_in_oneof = 2 [deprecated = true];
  GOOGLE_PROTOBUF_DEPRECATED_ATTR bool has_deprecated_int32_in_oneof() const;
  GOOGLE_PROTOBUF_DEPRECATED_ATTR void clear_deprecated_int32_in_oneof();
  GOOGLE_PROTOBUF_DEPRECATED_ATTR static const int kDeprecatedInt32InOneofFieldNumber = 2;
  GOOGLE_PROTOBUF_DEPRECATED_ATTR ::google::protobuf::int32 deprecated_int32_in_oneof() const;
  GOOGLE_PROTOBUF_DEPRECATED_ATTR void set_deprecated_int32_in_oneof(::google::protobuf::int32 value);

  void clear_oneof_fields();
  OneofFieldsCase oneof_fields_case() const;
  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestDeprecatedFields)
 private:
  void set_has_deprecated_int32();
  void clear_has_deprecated_int32();
  void set_has_deprecated_int32_in_oneof();

  inline bool has_oneof_fields() const;
  inline void clear_has_oneof_fields();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::int32 deprecated_int32_;
  union OneofFieldsUnion {
    OneofFieldsUnion() {}
    ::google::protobuf::int32 deprecated_int32_in_oneof_;
  } oneof_fields_;
  ::google::protobuf::uint32 _oneof_case_[1];

  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class TestDeprecatedMessage : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.TestDeprecatedMessage) */ {
 public:
  TestDeprecatedMessage();
  virtual ~TestDeprecatedMessage();

  TestDeprecatedMessage(const TestDeprecatedMessage& from);

  inline TestDeprecatedMessage& operator=(const TestDeprecatedMessage& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TestDeprecatedMessage(TestDeprecatedMessage&& from) noexcept
    : TestDeprecatedMessage() {
    *this = ::std::move(from);
  }

  inline TestDeprecatedMessage& operator=(TestDeprecatedMessage&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const TestDeprecatedMessage& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TestDeprecatedMessage* internal_default_instance() {
    return reinterpret_cast<const TestDeprecatedMessage*>(
               &_TestDeprecatedMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    6;

  void UnsafeArenaSwap(TestDeprecatedMessage* other);
  void Swap(TestDeprecatedMessage* other);
  friend void swap(TestDeprecatedMessage& a, TestDeprecatedMessage& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline TestDeprecatedMessage* New() const final {
    return CreateMaybeMessage<TestDeprecatedMessage>(NULL);
  }

  TestDeprecatedMessage* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestDeprecatedMessage>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestDeprecatedMessage& from);
  void MergeFrom(const TestDeprecatedMessage& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TestDeprecatedMessage* other);
  protected:
  explicit TestDeprecatedMessage(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestDeprecatedMessage)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class ForeignMessage : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.ForeignMessage) */ {
 public:
  ForeignMessage();
  virtual ~ForeignMessage();

  ForeignMessage(const ForeignMessage& from);

  inline ForeignMessage& operator=(const ForeignMessage& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  ForeignMessage(ForeignMessage&& from) noexcept
    : ForeignMessage() {
    *this = ::std::move(from);
  }

  inline ForeignMessage& operator=(ForeignMessage&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const ForeignMessage& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const ForeignMessage* internal_default_instance() {
    return reinterpret_cast<const ForeignMessage*>(
               &_ForeignMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    7;

  void UnsafeArenaSwap(ForeignMessage* other);
  void Swap(ForeignMessage* other);
  friend void swap(ForeignMessage& a, ForeignMessage& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline ForeignMessage* New() const final {
    return CreateMaybeMessage<ForeignMessage>(NULL);
  }

  ForeignMessage* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<ForeignMessage>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const ForeignMessage& from);
  void MergeFrom(const ForeignMessage& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ForeignMessage* other);
  protected:
  explicit ForeignMessage(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional int32 c = 1;
  bool has_c() const;
  void clear_c();
  static const int kCFieldNumber = 1;
  ::google::protobuf::int32 c() const;
  void set_c(::google::protobuf::int32 value);

  // optional int32 d = 2;
  bool has_d() const;
  void clear_d();
  static const int kDFieldNumber = 2;
  ::google::protobuf::int32 d() const;
  void set_d(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:protobuf_unittest.ForeignMessage)
 private:
  void set_has_c();
  void clear_has_c();
  void set_has_d();
  void clear_has_d();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::int32 c_;
  ::google::protobuf::int32 d_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class TestReservedFields : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.TestReservedFields) */ {
 public:
  TestReservedFields();
  virtual ~TestReservedFields();

  TestReservedFields(const TestReservedFields& from);

  inline TestReservedFields& operator=(const TestReservedFields& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TestReservedFields(TestReservedFields&& from) noexcept
    : TestReservedFields() {
    *this = ::std::move(from);
  }

  inline TestReservedFields& operator=(TestReservedFields&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const TestReservedFields& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TestReservedFields* internal_default_instance() {
    return reinterpret_cast<const TestReservedFields*>(
               &_TestReservedFields_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    8;

  void UnsafeArenaSwap(TestReservedFields* other);
  void Swap(TestReservedFields* other);
  friend void swap(TestReservedFields& a, TestReservedFields& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline TestReservedFields* New() const final {
    return CreateMaybeMessage<TestReservedFields>(NULL);
  }

  TestReservedFields* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestReservedFields>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestReservedFields& from);
  void MergeFrom(const TestReservedFields& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TestReservedFields* other);
  protected:
  explicit TestReservedFields(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestReservedFields)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class TestAllExtensions : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.TestAllExtensions) */ {
 public:
  TestAllExtensions();
  virtual ~TestAllExtensions();

  TestAllExtensions(const TestAllExtensions& from);

  inline TestAllExtensions& operator=(const TestAllExtensions& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TestAllExtensions(TestAllExtensions&& from) noexcept
    : TestAllExtensions() {
    *this = ::std::move(from);
  }

  inline TestAllExtensions& operator=(TestAllExtensions&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const TestAllExtensions& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TestAllExtensions* internal_default_instance() {
    return reinterpret_cast<const TestAllExtensions*>(
               &_TestAllExtensions_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    9;

  void UnsafeArenaSwap(TestAllExtensions* other);
  void Swap(TestAllExtensions* other);
  friend void swap(TestAllExtensions& a, TestAllExtensions& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline TestAllExtensions* New() const final {
    return CreateMaybeMessage<TestAllExtensions>(NULL);
  }

  TestAllExtensions* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestAllExtensions>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestAllExtensions& from);
  void MergeFrom(const TestAllExtensions& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TestAllExtensions* other);
  protected:
  explicit TestAllExtensions(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(TestAllExtensions)
  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestAllExtensions)
 private:

  ::google::protobuf::internal::ExtensionSet _extensions_;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class OptionalGroup_extension : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.OptionalGroup_extension) */ {
 public:
  OptionalGroup_extension();
  virtual ~OptionalGroup_extension();

  OptionalGroup_extension(const OptionalGroup_extension& from);

  inline OptionalGroup_extension& operator=(const OptionalGroup_extension& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  OptionalGroup_extension(OptionalGroup_extension&& from) noexcept
    : OptionalGroup_extension() {
    *this = ::std::move(from);
  }

  inline OptionalGroup_extension& operator=(OptionalGroup_extension&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const OptionalGroup_extension& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const OptionalGroup_extension* internal_default_instance() {
    return reinterpret_cast<const OptionalGroup_extension*>(
               &_OptionalGroup_extension_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    10;

  void UnsafeArenaSwap(OptionalGroup_extension* other);
  void Swap(OptionalGroup_extension* other);
  friend void swap(OptionalGroup_extension& a, OptionalGroup_extension& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline OptionalGroup_extension* New() const final {
    return CreateMaybeMessage<OptionalGroup_extension>(NULL);
  }

  OptionalGroup_extension* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<OptionalGroup_extension>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const OptionalGroup_extension& from);
  void MergeFrom(const OptionalGroup_extension& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(OptionalGroup_extension* other);
  protected:
  explicit OptionalGroup_extension(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional int32 a = 17;
  bool has_a() const;
  void clear_a();
  static const int kAFieldNumber = 17;
  ::google::protobuf::int32 a() const;
  void set_a(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:protobuf_unittest.OptionalGroup_extension)
 private:
  void set_has_a();
  void clear_has_a();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::int32 a_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class RepeatedGroup_extension : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.RepeatedGroup_extension) */ {
 public:
  RepeatedGroup_extension();
  virtual ~RepeatedGroup_extension();

  RepeatedGroup_extension(const RepeatedGroup_extension& from);

  inline RepeatedGroup_extension& operator=(const RepeatedGroup_extension& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  RepeatedGroup_extension(RepeatedGroup_extension&& from) noexcept
    : RepeatedGroup_extension() {
    *this = ::std::move(from);
  }

  inline RepeatedGroup_extension& operator=(RepeatedGroup_extension&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const RepeatedGroup_extension& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const RepeatedGroup_extension* internal_default_instance() {
    return reinterpret_cast<const RepeatedGroup_extension*>(
               &_RepeatedGroup_extension_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    11;

  void UnsafeArenaSwap(RepeatedGroup_extension* other);
  void Swap(RepeatedGroup_extension* other);
  friend void swap(RepeatedGroup_extension& a, RepeatedGroup_extension& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline RepeatedGroup_extension* New() const final {
    return CreateMaybeMessage<RepeatedGroup_extension>(NULL);
  }

  RepeatedGroup_extension* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<RepeatedGroup_extension>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const RepeatedGroup_extension& from);
  void MergeFrom(const RepeatedGroup_extension& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RepeatedGroup_extension* other);
  protected:
  explicit RepeatedGroup_extension(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional int32 a = 47;
  bool has_a() const;
  void clear_a();
  static const int kAFieldNumber = 47;
  ::google::protobuf::int32 a() const;
  void set_a(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:protobuf_unittest.RepeatedGroup_extension)
 private:
  void set_has_a();
  void clear_has_a();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::int32 a_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class TestGroup_OptionalGroup : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.TestGroup.OptionalGroup) */ {
 public:
  TestGroup_OptionalGroup();
  virtual ~TestGroup_OptionalGroup();

  TestGroup_OptionalGroup(const TestGroup_OptionalGroup& from);

  inline TestGroup_OptionalGroup& operator=(const TestGroup_OptionalGroup& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TestGroup_OptionalGroup(TestGroup_OptionalGroup&& from) noexcept
    : TestGroup_OptionalGroup() {
    *this = ::std::move(from);
  }

  inline TestGroup_OptionalGroup& operator=(TestGroup_OptionalGroup&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const TestGroup_OptionalGroup& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TestGroup_OptionalGroup* internal_default_instance() {
    return reinterpret_cast<const TestGroup_OptionalGroup*>(
               &_TestGroup_OptionalGroup_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    12;

  void UnsafeArenaSwap(TestGroup_OptionalGroup* other);
  void Swap(TestGroup_OptionalGroup* other);
  friend void swap(TestGroup_OptionalGroup& a, TestGroup_OptionalGroup& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline TestGroup_OptionalGroup* New() const final {
    return CreateMaybeMessage<TestGroup_OptionalGroup>(NULL);
  }

  TestGroup_OptionalGroup* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestGroup_OptionalGroup>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestGroup_OptionalGroup& from);
  void MergeFrom(const TestGroup_OptionalGroup& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TestGroup_OptionalGroup* other);
  protected:
  explicit TestGroup_OptionalGroup(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional int32 a = 17;
  bool has_a() const;
  void clear_a();
  static const int kAFieldNumber = 17;
  ::google::protobuf::int32 a() const;
  void set_a(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestGroup.OptionalGroup)
 private:
  void set_has_a();
  void clear_has_a();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::int32 a_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class TestGroup : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.TestGroup) */ {
 public:
  TestGroup();
  virtual ~TestGroup();

  TestGroup(const TestGroup& from);

  inline TestGroup& operator=(const TestGroup& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TestGroup(TestGroup&& from) noexcept
    : TestGroup() {
    *this = ::std::move(from);
  }

  inline TestGroup& operator=(TestGroup&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const TestGroup& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TestGroup* internal_default_instance() {
    return reinterpret_cast<const TestGroup*>(
               &_TestGroup_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    13;

  void UnsafeArenaSwap(TestGroup* other);
  void Swap(TestGroup* other);
  friend void swap(TestGroup& a, TestGroup& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline TestGroup* New() const final {
    return CreateMaybeMessage<TestGroup>(NULL);
  }

  TestGroup* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestGroup>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestGroup& from);
  void MergeFrom(const TestGroup& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TestGroup* other);
  protected:
  explicit TestGroup(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef TestGroup_OptionalGroup OptionalGroup;

  // accessors -------------------------------------------------------

  // optional group OptionalGroup = 16 { ... };
  bool has_optionalgroup() const;
  void clear_optionalgroup();
  static const int kOptionalgroupFieldNumber = 16;
  private:
  const ::protobuf_unittest::TestGroup_OptionalGroup& _internal_optionalgroup() const;
  public:
  const ::protobuf_unittest::TestGroup_OptionalGroup& optionalgroup() const;
  ::protobuf_unittest::TestGroup_OptionalGroup* release_optionalgroup();
  ::protobuf_unittest::TestGroup_OptionalGroup* mutable_optionalgroup();
  void set_allocated_optionalgroup(::protobuf_unittest::TestGroup_OptionalGroup* optionalgroup);
  void unsafe_arena_set_allocated_optionalgroup(
      ::protobuf_unittest::TestGroup_OptionalGroup* optionalgroup);
  ::protobuf_unittest::TestGroup_OptionalGroup* unsafe_arena_release_optionalgroup();

  // optional .protobuf_unittest.ForeignEnum optional_foreign_enum = 22;
  bool has_optional_foreign_enum() const;
  void clear_optional_foreign_enum();
  static const int kOptionalForeignEnumFieldNumber = 22;
  ::protobuf_unittest::ForeignEnum optional_foreign_enum() const;
  void set_optional_foreign_enum(::protobuf_unittest::ForeignEnum value);

  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestGroup)
 private:
  void set_has_optionalgroup();
  void clear_has_optionalgroup();
  void set_has_optional_foreign_enum();
  void clear_has_optional_foreign_enum();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::protobuf_unittest::TestGroup_OptionalGroup* optionalgroup_;
  int optional_foreign_enum_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class TestGroupExtension : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.TestGroupExtension) */ {
 public:
  TestGroupExtension();
  virtual ~TestGroupExtension();

  TestGroupExtension(const TestGroupExtension& from);

  inline TestGroupExtension& operator=(const TestGroupExtension& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TestGroupExtension(TestGroupExtension&& from) noexcept
    : TestGroupExtension() {
    *this = ::std::move(from);
  }

  inline TestGroupExtension& operator=(TestGroupExtension&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const TestGroupExtension& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TestGroupExtension* internal_default_instance() {
    return reinterpret_cast<const TestGroupExtension*>(
               &_TestGroupExtension_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    14;

  void UnsafeArenaSwap(TestGroupExtension* other);
  void Swap(TestGroupExtension* other);
  friend void swap(TestGroupExtension& a, TestGroupExtension& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline TestGroupExtension* New() const final {
    return CreateMaybeMessage<TestGroupExtension>(NULL);
  }

  TestGroupExtension* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestGroupExtension>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestGroupExtension& from);
  void MergeFrom(const TestGroupExtension& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TestGroupExtension* other);
  protected:
  explicit TestGroupExtension(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(TestGroupExtension)
  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestGroupExtension)
 private:

  ::google::protobuf::internal::ExtensionSet _extensions_;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class TestNestedExtension_OptionalGroup_extension : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.TestNestedExtension.OptionalGroup_extension) */ {
 public:
  TestNestedExtension_OptionalGroup_extension();
  virtual ~TestNestedExtension_OptionalGroup_extension();

  TestNestedExtension_OptionalGroup_extension(const TestNestedExtension_OptionalGroup_extension& from);

  inline TestNestedExtension_OptionalGroup_extension& operator=(const TestNestedExtension_OptionalGroup_extension& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TestNestedExtension_OptionalGroup_extension(TestNestedExtension_OptionalGroup_extension&& from) noexcept
    : TestNestedExtension_OptionalGroup_extension() {
    *this = ::std::move(from);
  }

  inline TestNestedExtension_OptionalGroup_extension& operator=(TestNestedExtension_OptionalGroup_extension&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const TestNestedExtension_OptionalGroup_extension& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TestNestedExtension_OptionalGroup_extension* internal_default_instance() {
    return reinterpret_cast<const TestNestedExtension_OptionalGroup_extension*>(
               &_TestNestedExtension_OptionalGroup_extension_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    15;

  void UnsafeArenaSwap(TestNestedExtension_OptionalGroup_extension* other);
  void Swap(TestNestedExtension_OptionalGroup_extension* other);
  friend void swap(TestNestedExtension_OptionalGroup_extension& a, TestNestedExtension_OptionalGroup_extension& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline TestNestedExtension_OptionalGroup_extension* New() const final {
    return CreateMaybeMessage<TestNestedExtension_OptionalGroup_extension>(NULL);
  }

  TestNestedExtension_OptionalGroup_extension* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestNestedExtension_OptionalGroup_extension>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestNestedExtension_OptionalGroup_extension& from);
  void MergeFrom(const TestNestedExtension_OptionalGroup_extension& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TestNestedExtension_OptionalGroup_extension* other);
  protected:
  explicit TestNestedExtension_OptionalGroup_extension(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional int32 a = 17;
  bool has_a() const;
  void clear_a();
  static const int kAFieldNumber = 17;
  ::google::protobuf::int32 a() const;
  void set_a(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestNestedExtension.OptionalGroup_extension)
 private:
  void set_has_a();
  void clear_has_a();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::int32 a_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class TestNestedExtension : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.TestNestedExtension) */ {
 public:
  TestNestedExtension();
  virtual ~TestNestedExtension();

  TestNestedExtension(const TestNestedExtension& from);

  inline TestNestedExtension& operator=(const TestNestedExtension& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TestNestedExtension(TestNestedExtension&& from) noexcept
    : TestNestedExtension() {
    *this = ::std::move(from);
  }

  inline TestNestedExtension& operator=(TestNestedExtension&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const TestNestedExtension& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TestNestedExtension* internal_default_instance() {
    return reinterpret_cast<const TestNestedExtension*>(
               &_TestNestedExtension_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    16;

  void UnsafeArenaSwap(TestNestedExtension* other);
  void Swap(TestNestedExtension* other);
  friend void swap(TestNestedExtension& a, TestNestedExtension& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline TestNestedExtension* New() const final {
    return CreateMaybeMessage<TestNestedExtension>(NULL);
  }

  TestNestedExtension* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestNestedExtension>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestNestedExtension& from);
  void MergeFrom(const TestNestedExtension& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TestNestedExtension* other);
  protected:
  explicit TestNestedExtension(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef TestNestedExtension_OptionalGroup_extension OptionalGroup_extension;

  // accessors -------------------------------------------------------

  static const int kTestFieldNumber = 1002;
  static ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestAllExtensions,
      ::google::protobuf::internal::StringTypeTraits, 9, false >
    test;
  static const int kNestedStringExtensionFieldNumber = 1003;
  static ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestAllExtensions,
      ::google::protobuf::internal::StringTypeTraits, 9, false >
    nested_string_extension;
  static const int kOptionalgroupExtensionFieldNumber = 16;
  static ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestGroupExtension,
      ::google::protobuf::internal::MessageTypeTraits< ::protobuf_unittest::TestNestedExtension_OptionalGroup_extension >, 10, false >
    optionalgroup_extension;
  static const int kOptionalForeignEnumExtensionFieldNumber = 22;
  static ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestGroupExtension,
      ::google::protobuf::internal::EnumTypeTraits< ::protobuf_unittest::ForeignEnum, ::protobuf_unittest::ForeignEnum_IsValid>, 14, false >
    optional_foreign_enum_extension;
  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestNestedExtension)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class TestRequired : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.TestRequired) */ {
 public:
  TestRequired();
  virtual ~TestRequired();

  TestRequired(const TestRequired& from);

  inline TestRequired& operator=(const TestRequired& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TestRequired(TestRequired&& from) noexcept
    : TestRequired() {
    *this = ::std::move(from);
  }

  inline TestRequired& operator=(TestRequired&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const TestRequired& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TestRequired* internal_default_instance() {
    return reinterpret_cast<const TestRequired*>(
               &_TestRequired_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    17;

  void UnsafeArenaSwap(TestRequired* other);
  void Swap(TestRequired* other);
  friend void swap(TestRequired& a, TestRequired& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline TestRequired* New() const final {
    return CreateMaybeMessage<TestRequired>(NULL);
  }

  TestRequired* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestRequired>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestRequired& from);
  void MergeFrom(const TestRequired& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TestRequired* other);
  protected:
  explicit TestRequired(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // required int32 a = 1;
  bool has_a() const;
  void clear_a();
  static const int kAFieldNumber = 1;
  ::google::protobuf::int32 a() const;
  void set_a(::google::protobuf::int32 value);

  // optional int32 dummy2 = 2;
  bool has_dummy2() const;
  void clear_dummy2();
  static const int kDummy2FieldNumber = 2;
  ::google::protobuf::int32 dummy2() const;
  void set_dummy2(::google::protobuf::int32 value);

  // required int32 b = 3;
  bool has_b() const;
  void clear_b();
  static const int kBFieldNumber = 3;
  ::google::protobuf::int32 b() const;
  void set_b(::google::protobuf::int32 value);

  // optional int32 dummy4 = 4;
  bool has_dummy4() const;
  void clear_dummy4();
  static const int kDummy4FieldNumber = 4;
  ::google::protobuf::int32 dummy4() const;
  void set_dummy4(::google::protobuf::int32 value);

  // optional int32 dummy5 = 5;
  bool has_dummy5() const;
  void clear_dummy5();
  static const int kDummy5FieldNumber = 5;
  ::google::protobuf::int32 dummy5() const;
  void set_dummy5(::google::protobuf::int32 value);

  // optional int32 dummy6 = 6;
  bool has_dummy6() const;
  void clear_dummy6();
  static const int kDummy6FieldNumber = 6;
  ::google::protobuf::int32 dummy6() const;
  void set_dummy6(::google::protobuf::int32 value);

  // optional int32 dummy7 = 7;
  bool has_dummy7() const;
  void clear_dummy7();
  static const int kDummy7FieldNumber = 7;
  ::google::protobuf::int32 dummy7() const;
  void set_dummy7(::google::protobuf::int32 value);

  // optional int32 dummy8 = 8;
  bool has_dummy8() const;
  void clear_dummy8();
  static const int kDummy8FieldNumber = 8;
  ::google::protobuf::int32 dummy8() const;
  void set_dummy8(::google::protobuf::int32 value);

  // optional int32 dummy9 = 9;
  bool has_dummy9() const;
  void clear_dummy9();
  static const int kDummy9FieldNumber = 9;
  ::google::protobuf::int32 dummy9() const;
  void set_dummy9(::google::protobuf::int32 value);

  // optional int32 dummy10 = 10;
  bool has_dummy10() const;
  void clear_dummy10();
  static const int kDummy10FieldNumber = 10;
  ::google::protobuf::int32 dummy10() const;
  void set_dummy10(::google::protobuf::int32 value);

  // optional int32 dummy11 = 11;
  bool has_dummy11() const;
  void clear_dummy11();
  static const int kDummy11FieldNumber = 11;
  ::google::protobuf::int32 dummy11() const;
  void set_dummy11(::google::protobuf::int32 value);

  // optional int32 dummy12 = 12;
  bool has_dummy12() const;
  void clear_dummy12();
  static const int kDummy12FieldNumber = 12;
  ::google::protobuf::int32 dummy12() const;
  void set_dummy12(::google::protobuf::int32 value);

  // optional int32 dummy13 = 13;
  bool has_dummy13() const;
  void clear_dummy13();
  static const int kDummy13FieldNumber = 13;
  ::google::protobuf::int32 dummy13() const;
  void set_dummy13(::google::protobuf::int32 value);

  // optional int32 dummy14 = 14;
  bool has_dummy14() const;
  void clear_dummy14();
  static const int kDummy14FieldNumber = 14;
  ::google::protobuf::int32 dummy14() const;
  void set_dummy14(::google::protobuf::int32 value);

  // optional int32 dummy15 = 15;
  bool has_dummy15() const;
  void clear_dummy15();
  static const int kDummy15FieldNumber = 15;
  ::google::protobuf::int32 dummy15() const;
  void set_dummy15(::google::protobuf::int32 value);

  // optional int32 dummy16 = 16;
  bool has_dummy16() const;
  void clear_dummy16();
  static const int kDummy16FieldNumber = 16;
  ::google::protobuf::int32 dummy16() const;
  void set_dummy16(::google::protobuf::int32 value);

  // optional int32 dummy17 = 17;
  bool has_dummy17() const;
  void clear_dummy17();
  static const int kDummy17FieldNumber = 17;
  ::google::protobuf::int32 dummy17() const;
  void set_dummy17(::google::protobuf::int32 value);

  // optional int32 dummy18 = 18;
  bool has_dummy18() const;
  void clear_dummy18();
  static const int kDummy18FieldNumber = 18;
  ::google::protobuf::int32 dummy18() const;
  void set_dummy18(::google::protobuf::int32 value);

  // optional int32 dummy19 = 19;
  bool has_dummy19() const;
  void clear_dummy19();
  static const int kDummy19FieldNumber = 19;
  ::google::protobuf::int32 dummy19() const;
  void set_dummy19(::google::protobuf::int32 value);

  // optional int32 dummy20 = 20;
  bool has_dummy20() const;
  void clear_dummy20();
  static const int kDummy20FieldNumber = 20;
  ::google::protobuf::int32 dummy20() const;
  void set_dummy20(::google::protobuf::int32 value);

  // optional int32 dummy21 = 21;
  bool has_dummy21() const;
  void clear_dummy21();
  static const int kDummy21FieldNumber = 21;
  ::google::protobuf::int32 dummy21() const;
  void set_dummy21(::google::protobuf::int32 value);

  // optional int32 dummy22 = 22;
  bool has_dummy22() const;
  void clear_dummy22();
  static const int kDummy22FieldNumber = 22;
  ::google::protobuf::int32 dummy22() const;
  void set_dummy22(::google::protobuf::int32 value);

  // optional int32 dummy23 = 23;
  bool has_dummy23() const;
  void clear_dummy23();
  static const int kDummy23FieldNumber = 23;
  ::google::protobuf::int32 dummy23() const;
  void set_dummy23(::google::protobuf::int32 value);

  // optional int32 dummy24 = 24;
  bool has_dummy24() const;
  void clear_dummy24();
  static const int kDummy24FieldNumber = 24;
  ::google::protobuf::int32 dummy24() const;
  void set_dummy24(::google::protobuf::int32 value);

  // optional int32 dummy25 = 25;
  bool has_dummy25() const;
  void clear_dummy25();
  static const int kDummy25FieldNumber = 25;
  ::google::protobuf::int32 dummy25() const;
  void set_dummy25(::google::protobuf::int32 value);

  // optional int32 dummy26 = 26;
  bool has_dummy26() const;
  void clear_dummy26();
  static const int kDummy26FieldNumber = 26;
  ::google::protobuf::int32 dummy26() const;
  void set_dummy26(::google::protobuf::int32 value);

  // optional int32 dummy27 = 27;
  bool has_dummy27() const;
  void clear_dummy27();
  static const int kDummy27FieldNumber = 27;
  ::google::protobuf::int32 dummy27() const;
  void set_dummy27(::google::protobuf::int32 value);

  // optional int32 dummy28 = 28;
  bool has_dummy28() const;
  void clear_dummy28();
  static const int kDummy28FieldNumber = 28;
  ::google::protobuf::int32 dummy28() const;
  void set_dummy28(::google::protobuf::int32 value);

  // optional int32 dummy29 = 29;
  bool has_dummy29() const;
  void clear_dummy29();
  static const int kDummy29FieldNumber = 29;
  ::google::protobuf::int32 dummy29() const;
  void set_dummy29(::google::protobuf::int32 value);

  // optional int32 dummy30 = 30;
  bool has_dummy30() const;
  void clear_dummy30();
  static const int kDummy30FieldNumber = 30;
  ::google::protobuf::int32 dummy30() const;
  void set_dummy30(::google::protobuf::int32 value);

  // optional int32 dummy31 = 31;
  bool has_dummy31() const;
  void clear_dummy31();
  static const int kDummy31FieldNumber = 31;
  ::google::protobuf::int32 dummy31() const;
  void set_dummy31(::google::protobuf::int32 value);

  // optional int32 dummy32 = 32;
  bool has_dummy32() const;
  void clear_dummy32();
  static const int kDummy32FieldNumber = 32;
  ::google::protobuf::int32 dummy32() const;
  void set_dummy32(::google::protobuf::int32 value);

  // required int32 c = 33;
  bool has_c() const;
  void clear_c();
  static const int kCFieldNumber = 33;
  ::google::protobuf::int32 c() const;
  void set_c(::google::protobuf::int32 value);

  static const int kSingleFieldNumber = 1000;
  static ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestAllExtensions,
      ::google::protobuf::internal::MessageTypeTraits< ::protobuf_unittest::TestRequired >, 11, false >
    single;
  static const int kMultiFieldNumber = 1001;
  static ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestAllExtensions,
      ::google::protobuf::internal::RepeatedMessageTypeTraits< ::protobuf_unittest::TestRequired >, 11, false >
    multi;
  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestRequired)
 private:
  void set_has_a();
  void clear_has_a();
  void set_has_dummy2();
  void clear_has_dummy2();
  void set_has_b();
  void clear_has_b();
  void set_has_dummy4();
  void clear_has_dummy4();
  void set_has_dummy5();
  void clear_has_dummy5();
  void set_has_dummy6();
  void clear_has_dummy6();
  void set_has_dummy7();
  void clear_has_dummy7();
  void set_has_dummy8();
  void clear_has_dummy8();
  void set_has_dummy9();
  void clear_has_dummy9();
  void set_has_dummy10();
  void clear_has_dummy10();
  void set_has_dummy11();
  void clear_has_dummy11();
  void set_has_dummy12();
  void clear_has_dummy12();
  void set_has_dummy13();
  void clear_has_dummy13();
  void set_has_dummy14();
  void clear_has_dummy14();
  void set_has_dummy15();
  void clear_has_dummy15();
  void set_has_dummy16();
  void clear_has_dummy16();
  void set_has_dummy17();
  void clear_has_dummy17();
  void set_has_dummy18();
  void clear_has_dummy18();
  void set_has_dummy19();
  void clear_has_dummy19();
  void set_has_dummy20();
  void clear_has_dummy20();
  void set_has_dummy21();
  void clear_has_dummy21();
  void set_has_dummy22();
  void clear_has_dummy22();
  void set_has_dummy23();
  void clear_has_dummy23();
  void set_has_dummy24();
  void clear_has_dummy24();
  void set_has_dummy25();
  void clear_has_dummy25();
  void set_has_dummy26();
  void clear_has_dummy26();
  void set_has_dummy27();
  void clear_has_dummy27();
  void set_has_dummy28();
  void clear_has_dummy28();
  void set_has_dummy29();
  void clear_has_dummy29();
  void set_has_dummy30();
  void clear_has_dummy30();
  void set_has_dummy31();
  void clear_has_dummy31();
  void set_has_dummy32();
  void clear_has_dummy32();
  void set_has_c();
  void clear_has_c();

  // helper for ByteSizeLong()
  size_t RequiredFieldsByteSizeFallback() const;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<2> _has_bits_;
  ::google::protobuf::int32 a_;
  ::google::protobuf::int32 dummy2_;
  ::google::protobuf::int32 b_;
  ::google::protobuf::int32 dummy4_;
  ::google::protobuf::int32 dummy5_;
  ::google::protobuf::int32 dummy6_;
  ::google::protobuf::int32 dummy7_;
  ::google::protobuf::int32 dummy8_;
  ::google::protobuf::int32 dummy9_;
  ::google::protobuf::int32 dummy10_;
  ::google::protobuf::int32 dummy11_;
  ::google::protobuf::int32 dummy12_;
  ::google::protobuf::int32 dummy13_;
  ::google::protobuf::int32 dummy14_;
  ::google::protobuf::int32 dummy15_;
  ::google::protobuf::int32 dummy16_;
  ::google::protobuf::int32 dummy17_;
  ::google::protobuf::int32 dummy18_;
  ::google::protobuf::int32 dummy19_;
  ::google::protobuf::int32 dummy20_;
  ::google::protobuf::int32 dummy21_;
  ::google::protobuf::int32 dummy22_;
  ::google::protobuf::int32 dummy23_;
  ::google::protobuf::int32 dummy24_;
  ::google::protobuf::int32 dummy25_;
  ::google::protobuf::int32 dummy26_;
  ::google::protobuf::int32 dummy27_;
  ::google::protobuf::int32 dummy28_;
  ::google::protobuf::int32 dummy29_;
  ::google::protobuf::int32 dummy30_;
  ::google::protobuf::int32 dummy31_;
  ::google::protobuf::int32 dummy32_;
  ::google::protobuf::int32 c_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class TestRequiredForeign : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.TestRequiredForeign) */ {
 public:
  TestRequiredForeign();
  virtual ~TestRequiredForeign();

  TestRequiredForeign(const TestRequiredForeign& from);

  inline TestRequiredForeign& operator=(const TestRequiredForeign& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TestRequiredForeign(TestRequiredForeign&& from) noexcept
    : TestRequiredForeign() {
    *this = ::std::move(from);
  }

  inline TestRequiredForeign& operator=(TestRequiredForeign&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const TestRequiredForeign& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TestRequiredForeign* internal_default_instance() {
    return reinterpret_cast<const TestRequiredForeign*>(
               &_TestRequiredForeign_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    18;

  void UnsafeArenaSwap(TestRequiredForeign* other);
  void Swap(TestRequiredForeign* other);
  friend void swap(TestRequiredForeign& a, TestRequiredForeign& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline TestRequiredForeign* New() const final {
    return CreateMaybeMessage<TestRequiredForeign>(NULL);
  }

  TestRequiredForeign* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestRequiredForeign>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestRequiredForeign& from);
  void MergeFrom(const TestRequiredForeign& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TestRequiredForeign* other);
  protected:
  explicit TestRequiredForeign(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated .protobuf_unittest.TestRequired repeated_message = 2;
  int repeated_message_size() const;
  void clear_repeated_message();
  static const int kRepeatedMessageFieldNumber = 2;
  ::protobuf_unittest::TestRequired* mutable_repeated_message(int index);
  ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::TestRequired >*
      mutable_repeated_message();
  const ::protobuf_unittest::TestRequired& repeated_message(int index) const;
  ::protobuf_unittest::TestRequired* add_repeated_message();
  const ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::TestRequired >&
      repeated_message() const;

  // optional .protobuf_unittest.TestRequired optional_message = 1;
  bool has_optional_message() const;
  void clear_optional_message();
  static const int kOptionalMessageFieldNumber = 1;
  private:
  const ::protobuf_unittest::TestRequired& _internal_optional_message() const;
  public:
  const ::protobuf_unittest::TestRequired& optional_message() const;
  ::protobuf_unittest::TestRequired* release_optional_message();
  ::protobuf_unittest::TestRequired* mutable_optional_message();
  void set_allocated_optional_message(::protobuf_unittest::TestRequired* optional_message);
  void unsafe_arena_set_allocated_optional_message(
      ::protobuf_unittest::TestRequired* optional_message);
  ::protobuf_unittest::TestRequired* unsafe_arena_release_optional_message();

  // optional int32 dummy = 3;
  bool has_dummy() const;
  void clear_dummy();
  static const int kDummyFieldNumber = 3;
  ::google::protobuf::int32 dummy() const;
  void set_dummy(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestRequiredForeign)
 private:
  void set_has_optional_message();
  void clear_has_optional_message();
  void set_has_dummy();
  void clear_has_dummy();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::TestRequired > repeated_message_;
  ::protobuf_unittest::TestRequired* optional_message_;
  ::google::protobuf::int32 dummy_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class TestRequiredMessage : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.TestRequiredMessage) */ {
 public:
  TestRequiredMessage();
  virtual ~TestRequiredMessage();

  TestRequiredMessage(const TestRequiredMessage& from);

  inline TestRequiredMessage& operator=(const TestRequiredMessage& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TestRequiredMessage(TestRequiredMessage&& from) noexcept
    : TestRequiredMessage() {
    *this = ::std::move(from);
  }

  inline TestRequiredMessage& operator=(TestRequiredMessage&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const TestRequiredMessage& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TestRequiredMessage* internal_default_instance() {
    return reinterpret_cast<const TestRequiredMessage*>(
               &_TestRequiredMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    19;

  void UnsafeArenaSwap(TestRequiredMessage* other);
  void Swap(TestRequiredMessage* other);
  friend void swap(TestRequiredMessage& a, TestRequiredMessage& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline TestRequiredMessage* New() const final {
    return CreateMaybeMessage<TestRequiredMessage>(NULL);
  }

  TestRequiredMessage* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestRequiredMessage>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestRequiredMessage& from);
  void MergeFrom(const TestRequiredMessage& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TestRequiredMessage* other);
  protected:
  explicit TestRequiredMessage(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated .protobuf_unittest.TestRequired repeated_message = 2;
  int repeated_message_size() const;
  void clear_repeated_message();
  static const int kRepeatedMessageFieldNumber = 2;
  ::protobuf_unittest::TestRequired* mutable_repeated_message(int index);
  ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::TestRequired >*
      mutable_repeated_message();
  const ::protobuf_unittest::TestRequired& repeated_message(int index) const;
  ::protobuf_unittest::TestRequired* add_repeated_message();
  const ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::TestRequired >&
      repeated_message() const;

  // optional .protobuf_unittest.TestRequired optional_message = 1;
  bool has_optional_message() const;
  void clear_optional_message();
  static const int kOptionalMessageFieldNumber = 1;
  private:
  const ::protobuf_unittest::TestRequired& _internal_optional_message() const;
  public:
  const ::protobuf_unittest::TestRequired& optional_message() const;
  ::protobuf_unittest::TestRequired* release_optional_message();
  ::protobuf_unittest::TestRequired* mutable_optional_message();
  void set_allocated_optional_message(::protobuf_unittest::TestRequired* optional_message);
  void unsafe_arena_set_allocated_optional_message(
      ::protobuf_unittest::TestRequired* optional_message);
  ::protobuf_unittest::TestRequired* unsafe_arena_release_optional_message();

  // required .protobuf_unittest.TestRequired required_message = 3;
  bool has_required_message() const;
  void clear_required_message();
  static const int kRequiredMessageFieldNumber = 3;
  private:
  const ::protobuf_unittest::TestRequired& _internal_required_message() const;
  public:
  const ::protobuf_unittest::TestRequired& required_message() const;
  ::protobuf_unittest::TestRequired* release_required_message();
  ::protobuf_unittest::TestRequired* mutable_required_message();
  void set_allocated_required_message(::protobuf_unittest::TestRequired* required_message);
  void unsafe_arena_set_allocated_required_message(
      ::protobuf_unittest::TestRequired* required_message);
  ::protobuf_unittest::TestRequired* unsafe_arena_release_required_message();

  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestRequiredMessage)
 private:
  void set_has_optional_message();
  void clear_has_optional_message();
  void set_has_required_message();
  void clear_has_required_message();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::TestRequired > repeated_message_;
  ::protobuf_unittest::TestRequired* optional_message_;
  ::protobuf_unittest::TestRequired* required_message_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class TestForeignNested : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.TestForeignNested) */ {
 public:
  TestForeignNested();
  virtual ~TestForeignNested();

  TestForeignNested(const TestForeignNested& from);

  inline TestForeignNested& operator=(const TestForeignNested& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TestForeignNested(TestForeignNested&& from) noexcept
    : TestForeignNested() {
    *this = ::std::move(from);
  }

  inline TestForeignNested& operator=(TestForeignNested&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const TestForeignNested& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TestForeignNested* internal_default_instance() {
    return reinterpret_cast<const TestForeignNested*>(
               &_TestForeignNested_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    20;

  void UnsafeArenaSwap(TestForeignNested* other);
  void Swap(TestForeignNested* other);
  friend void swap(TestForeignNested& a, TestForeignNested& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline TestForeignNested* New() const final {
    return CreateMaybeMessage<TestForeignNested>(NULL);
  }

  TestForeignNested* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestForeignNested>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestForeignNested& from);
  void MergeFrom(const TestForeignNested& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TestForeignNested* other);
  protected:
  explicit TestForeignNested(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .protobuf_unittest.TestAllTypes.NestedMessage foreign_nested = 1;
  bool has_foreign_nested() const;
  void clear_foreign_nested();
  static const int kForeignNestedFieldNumber = 1;
  private:
  const ::protobuf_unittest::TestAllTypes_NestedMessage& _internal_foreign_nested() const;
  public:
  const ::protobuf_unittest::TestAllTypes_NestedMessage& foreign_nested() const;
  ::protobuf_unittest::TestAllTypes_NestedMessage* release_foreign_nested();
  ::protobuf_unittest::TestAllTypes_NestedMessage* mutable_foreign_nested();
  void set_allocated_foreign_nested(::protobuf_unittest::TestAllTypes_NestedMessage* foreign_nested);
  void unsafe_arena_set_allocated_foreign_nested(
      ::protobuf_unittest::TestAllTypes_NestedMessage* foreign_nested);
  ::protobuf_unittest::TestAllTypes_NestedMessage* unsafe_arena_release_foreign_nested();

  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestForeignNested)
 private:
  void set_has_foreign_nested();
  void clear_has_foreign_nested();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::protobuf_unittest::TestAllTypes_NestedMessage* foreign_nested_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class TestEmptyMessage : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.TestEmptyMessage) */ {
 public:
  TestEmptyMessage();
  virtual ~TestEmptyMessage();

  TestEmptyMessage(const TestEmptyMessage& from);

  inline TestEmptyMessage& operator=(const TestEmptyMessage& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TestEmptyMessage(TestEmptyMessage&& from) noexcept
    : TestEmptyMessage() {
    *this = ::std::move(from);
  }

  inline TestEmptyMessage& operator=(TestEmptyMessage&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const TestEmptyMessage& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TestEmptyMessage* internal_default_instance() {
    return reinterpret_cast<const TestEmptyMessage*>(
               &_TestEmptyMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    21;

  void UnsafeArenaSwap(TestEmptyMessage* other);
  void Swap(TestEmptyMessage* other);
  friend void swap(TestEmptyMessage& a, TestEmptyMessage& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline TestEmptyMessage* New() const final {
    return CreateMaybeMessage<TestEmptyMessage>(NULL);
  }

  TestEmptyMessage* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestEmptyMessage>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestEmptyMessage& from);
  void MergeFrom(const TestEmptyMessage& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TestEmptyMessage* other);
  protected:
  explicit TestEmptyMessage(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestEmptyMessage)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class TestEmptyMessageWithExtensions : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.TestEmptyMessageWithExtensions) */ {
 public:
  TestEmptyMessageWithExtensions();
  virtual ~TestEmptyMessageWithExtensions();

  TestEmptyMessageWithExtensions(const TestEmptyMessageWithExtensions& from);

  inline TestEmptyMessageWithExtensions& operator=(const TestEmptyMessageWithExtensions& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TestEmptyMessageWithExtensions(TestEmptyMessageWithExtensions&& from) noexcept
    : TestEmptyMessageWithExtensions() {
    *this = ::std::move(from);
  }

  inline TestEmptyMessageWithExtensions& operator=(TestEmptyMessageWithExtensions&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const TestEmptyMessageWithExtensions& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TestEmptyMessageWithExtensions* internal_default_instance() {
    return reinterpret_cast<const TestEmptyMessageWithExtensions*>(
               &_TestEmptyMessageWithExtensions_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    22;

  void UnsafeArenaSwap(TestEmptyMessageWithExtensions* other);
  void Swap(TestEmptyMessageWithExtensions* other);
  friend void swap(TestEmptyMessageWithExtensions& a, TestEmptyMessageWithExtensions& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline TestEmptyMessageWithExtensions* New() const final {
    return CreateMaybeMessage<TestEmptyMessageWithExtensions>(NULL);
  }

  TestEmptyMessageWithExtensions* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestEmptyMessageWithExtensions>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestEmptyMessageWithExtensions& from);
  void MergeFrom(const TestEmptyMessageWithExtensions& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TestEmptyMessageWithExtensions* other);
  protected:
  explicit TestEmptyMessageWithExtensions(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(TestEmptyMessageWithExtensions)
  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestEmptyMessageWithExtensions)
 private:

  ::google::protobuf::internal::ExtensionSet _extensions_;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class TestMultipleExtensionRanges : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.TestMultipleExtensionRanges) */ {
 public:
  TestMultipleExtensionRanges();
  virtual ~TestMultipleExtensionRanges();

  TestMultipleExtensionRanges(const TestMultipleExtensionRanges& from);

  inline TestMultipleExtensionRanges& operator=(const TestMultipleExtensionRanges& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TestMultipleExtensionRanges(TestMultipleExtensionRanges&& from) noexcept
    : TestMultipleExtensionRanges() {
    *this = ::std::move(from);
  }

  inline TestMultipleExtensionRanges& operator=(TestMultipleExtensionRanges&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const TestMultipleExtensionRanges& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TestMultipleExtensionRanges* internal_default_instance() {
    return reinterpret_cast<const TestMultipleExtensionRanges*>(
               &_TestMultipleExtensionRanges_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    23;

  void UnsafeArenaSwap(TestMultipleExtensionRanges* other);
  void Swap(TestMultipleExtensionRanges* other);
  friend void swap(TestMultipleExtensionRanges& a, TestMultipleExtensionRanges& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline TestMultipleExtensionRanges* New() const final {
    return CreateMaybeMessage<TestMultipleExtensionRanges>(NULL);
  }

  TestMultipleExtensionRanges* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestMultipleExtensionRanges>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestMultipleExtensionRanges& from);
  void MergeFrom(const TestMultipleExtensionRanges& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TestMultipleExtensionRanges* other);
  protected:
  explicit TestMultipleExtensionRanges(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(TestMultipleExtensionRanges)
  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestMultipleExtensionRanges)
 private:

  ::google::protobuf::internal::ExtensionSet _extensions_;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class TestReallyLargeTagNumber : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.TestReallyLargeTagNumber) */ {
 public:
  TestReallyLargeTagNumber();
  virtual ~TestReallyLargeTagNumber();

  TestReallyLargeTagNumber(const TestReallyLargeTagNumber& from);

  inline TestReallyLargeTagNumber& operator=(const TestReallyLargeTagNumber& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TestReallyLargeTagNumber(TestReallyLargeTagNumber&& from) noexcept
    : TestReallyLargeTagNumber() {
    *this = ::std::move(from);
  }

  inline TestReallyLargeTagNumber& operator=(TestReallyLargeTagNumber&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const TestReallyLargeTagNumber& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TestReallyLargeTagNumber* internal_default_instance() {
    return reinterpret_cast<const TestReallyLargeTagNumber*>(
               &_TestReallyLargeTagNumber_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    24;

  void UnsafeArenaSwap(TestReallyLargeTagNumber* other);
  void Swap(TestReallyLargeTagNumber* other);
  friend void swap(TestReallyLargeTagNumber& a, TestReallyLargeTagNumber& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline TestReallyLargeTagNumber* New() const final {
    return CreateMaybeMessage<TestReallyLargeTagNumber>(NULL);
  }

  TestReallyLargeTagNumber* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestReallyLargeTagNumber>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestReallyLargeTagNumber& from);
  void MergeFrom(const TestReallyLargeTagNumber& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TestReallyLargeTagNumber* other);
  protected:
  explicit TestReallyLargeTagNumber(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional int32 a = 1;
  bool has_a() const;
  void clear_a();
  static const int kAFieldNumber = 1;
  ::google::protobuf::int32 a() const;
  void set_a(::google::protobuf::int32 value);

  // optional int32 bb = 268435455;
  bool has_bb() const;
  void clear_bb();
  static const int kBbFieldNumber = 268435455;
  ::google::protobuf::int32 bb() const;
  void set_bb(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestReallyLargeTagNumber)
 private:
  void set_has_a();
  void clear_has_a();
  void set_has_bb();
  void clear_has_bb();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::int32 a_;
  ::google::protobuf::int32 bb_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class TestRecursiveMessage : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.TestRecursiveMessage) */ {
 public:
  TestRecursiveMessage();
  virtual ~TestRecursiveMessage();

  TestRecursiveMessage(const TestRecursiveMessage& from);

  inline TestRecursiveMessage& operator=(const TestRecursiveMessage& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TestRecursiveMessage(TestRecursiveMessage&& from) noexcept
    : TestRecursiveMessage() {
    *this = ::std::move(from);
  }

  inline TestRecursiveMessage& operator=(TestRecursiveMessage&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const TestRecursiveMessage& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TestRecursiveMessage* internal_default_instance() {
    return reinterpret_cast<const TestRecursiveMessage*>(
               &_TestRecursiveMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    25;

  void UnsafeArenaSwap(TestRecursiveMessage* other);
  void Swap(TestRecursiveMessage* other);
  friend void swap(TestRecursiveMessage& a, TestRecursiveMessage& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline TestRecursiveMessage* New() const final {
    return CreateMaybeMessage<TestRecursiveMessage>(NULL);
  }

  TestRecursiveMessage* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestRecursiveMessage>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestRecursiveMessage& from);
  void MergeFrom(const TestRecursiveMessage& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TestRecursiveMessage* other);
  protected:
  explicit TestRecursiveMessage(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .protobuf_unittest.TestRecursiveMessage a = 1;
  bool has_a() const;
  void clear_a();
  static const int kAFieldNumber = 1;
  private:
  const ::protobuf_unittest::TestRecursiveMessage& _internal_a() const;
  public:
  const ::protobuf_unittest::TestRecursiveMessage& a() const;
  ::protobuf_unittest::TestRecursiveMessage* release_a();
  ::protobuf_unittest::TestRecursiveMessage* mutable_a();
  void set_allocated_a(::protobuf_unittest::TestRecursiveMessage* a);
  void unsafe_arena_set_allocated_a(
      ::protobuf_unittest::TestRecursiveMessage* a);
  ::protobuf_unittest::TestRecursiveMessage* unsafe_arena_release_a();

  // optional int32 i = 2;
  bool has_i() const;
  void clear_i();
  static const int kIFieldNumber = 2;
  ::google::protobuf::int32 i() const;
  void set_i(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestRecursiveMessage)
 private:
  void set_has_a();
  void clear_has_a();
  void set_has_i();
  void clear_has_i();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::protobuf_unittest::TestRecursiveMessage* a_;
  ::google::protobuf::int32 i_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class TestMutualRecursionA_SubMessage : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.TestMutualRecursionA.SubMessage) */ {
 public:
  TestMutualRecursionA_SubMessage();
  virtual ~TestMutualRecursionA_SubMessage();

  TestMutualRecursionA_SubMessage(const TestMutualRecursionA_SubMessage& from);

  inline TestMutualRecursionA_SubMessage& operator=(const TestMutualRecursionA_SubMessage& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TestMutualRecursionA_SubMessage(TestMutualRecursionA_SubMessage&& from) noexcept
    : TestMutualRecursionA_SubMessage() {
    *this = ::std::move(from);
  }

  inline TestMutualRecursionA_SubMessage& operator=(TestMutualRecursionA_SubMessage&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const TestMutualRecursionA_SubMessage& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TestMutualRecursionA_SubMessage* internal_default_instance() {
    return reinterpret_cast<const TestMutualRecursionA_SubMessage*>(
               &_TestMutualRecursionA_SubMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    26;

  void UnsafeArenaSwap(TestMutualRecursionA_SubMessage* other);
  void Swap(TestMutualRecursionA_SubMessage* other);
  friend void swap(TestMutualRecursionA_SubMessage& a, TestMutualRecursionA_SubMessage& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline TestMutualRecursionA_SubMessage* New() const final {
    return CreateMaybeMessage<TestMutualRecursionA_SubMessage>(NULL);
  }

  TestMutualRecursionA_SubMessage* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestMutualRecursionA_SubMessage>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestMutualRecursionA_SubMessage& from);
  void MergeFrom(const TestMutualRecursionA_SubMessage& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TestMutualRecursionA_SubMessage* other);
  protected:
  explicit TestMutualRecursionA_SubMessage(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .protobuf_unittest.TestMutualRecursionB b = 1;
  bool has_b() const;
  void clear_b();
  static const int kBFieldNumber = 1;
  private:
  const ::protobuf_unittest::TestMutualRecursionB& _internal_b() const;
  public:
  const ::protobuf_unittest::TestMutualRecursionB& b() const;
  ::protobuf_unittest::TestMutualRecursionB* release_b();
  ::protobuf_unittest::TestMutualRecursionB* mutable_b();
  void set_allocated_b(::protobuf_unittest::TestMutualRecursionB* b);
  void unsafe_arena_set_allocated_b(
      ::protobuf_unittest::TestMutualRecursionB* b);
  ::protobuf_unittest::TestMutualRecursionB* unsafe_arena_release_b();

  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestMutualRecursionA.SubMessage)
 private:
  void set_has_b();
  void clear_has_b();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::protobuf_unittest::TestMutualRecursionB* b_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class TestMutualRecursionA_SubGroup : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.TestMutualRecursionA.SubGroup) */ {
 public:
  TestMutualRecursionA_SubGroup();
  virtual ~TestMutualRecursionA_SubGroup();

  TestMutualRecursionA_SubGroup(const TestMutualRecursionA_SubGroup& from);

  inline TestMutualRecursionA_SubGroup& operator=(const TestMutualRecursionA_SubGroup& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TestMutualRecursionA_SubGroup(TestMutualRecursionA_SubGroup&& from) noexcept
    : TestMutualRecursionA_SubGroup() {
    *this = ::std::move(from);
  }

  inline TestMutualRecursionA_SubGroup& operator=(TestMutualRecursionA_SubGroup&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const TestMutualRecursionA_SubGroup& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TestMutualRecursionA_SubGroup* internal_default_instance() {
    return reinterpret_cast<const TestMutualRecursionA_SubGroup*>(
               &_TestMutualRecursionA_SubGroup_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    27;

  void UnsafeArenaSwap(TestMutualRecursionA_SubGroup* other);
  void Swap(TestMutualRecursionA_SubGroup* other);
  friend void swap(TestMutualRecursionA_SubGroup& a, TestMutualRecursionA_SubGroup& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline TestMutualRecursionA_SubGroup* New() const final {
    return CreateMaybeMessage<TestMutualRecursionA_SubGroup>(NULL);
  }

  TestMutualRecursionA_SubGroup* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestMutualRecursionA_SubGroup>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestMutualRecursionA_SubGroup& from);
  void MergeFrom(const TestMutualRecursionA_SubGroup& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TestMutualRecursionA_SubGroup* other);
  protected:
  explicit TestMutualRecursionA_SubGroup(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .protobuf_unittest.TestMutualRecursionA.SubMessage sub_message = 3;
  bool has_sub_message() const;
  void clear_sub_message();
  static const int kSubMessageFieldNumber = 3;
  private:
  const ::protobuf_unittest::TestMutualRecursionA_SubMessage& _internal_sub_message() const;
  public:
  const ::protobuf_unittest::TestMutualRecursionA_SubMessage& sub_message() const;
  ::protobuf_unittest::TestMutualRecursionA_SubMessage* release_sub_message();
  ::protobuf_unittest::TestMutualRecursionA_SubMessage* mutable_sub_message();
  void set_allocated_sub_message(::protobuf_unittest::TestMutualRecursionA_SubMessage* sub_message);
  void unsafe_arena_set_allocated_sub_message(
      ::protobuf_unittest::TestMutualRecursionA_SubMessage* sub_message);
  ::protobuf_unittest::TestMutualRecursionA_SubMessage* unsafe_arena_release_sub_message();

  // optional .protobuf_unittest.TestAllTypes not_in_this_scc = 4;
  bool has_not_in_this_scc() const;
  void clear_not_in_this_scc();
  static const int kNotInThisSccFieldNumber = 4;
  private:
  const ::protobuf_unittest::TestAllTypes& _internal_not_in_this_scc() const;
  public:
  const ::protobuf_unittest::TestAllTypes& not_in_this_scc() const;
  ::protobuf_unittest::TestAllTypes* release_not_in_this_scc();
  ::protobuf_unittest::TestAllTypes* mutable_not_in_this_scc();
  void set_allocated_not_in_this_scc(::protobuf_unittest::TestAllTypes* not_in_this_scc);
  void unsafe_arena_set_allocated_not_in_this_scc(
      ::protobuf_unittest::TestAllTypes* not_in_this_scc);
  ::protobuf_unittest::TestAllTypes* unsafe_arena_release_not_in_this_scc();

  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestMutualRecursionA.SubGroup)
 private:
  void set_has_sub_message();
  void clear_has_sub_message();
  void set_has_not_in_this_scc();
  void clear_has_not_in_this_scc();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::protobuf_unittest::TestMutualRecursionA_SubMessage* sub_message_;
  ::protobuf_unittest::TestAllTypes* not_in_this_scc_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class TestMutualRecursionA : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.TestMutualRecursionA) */ {
 public:
  TestMutualRecursionA();
  virtual ~TestMutualRecursionA();

  TestMutualRecursionA(const TestMutualRecursionA& from);

  inline TestMutualRecursionA& operator=(const TestMutualRecursionA& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TestMutualRecursionA(TestMutualRecursionA&& from) noexcept
    : TestMutualRecursionA() {
    *this = ::std::move(from);
  }

  inline TestMutualRecursionA& operator=(TestMutualRecursionA&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const TestMutualRecursionA& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TestMutualRecursionA* internal_default_instance() {
    return reinterpret_cast<const TestMutualRecursionA*>(
               &_TestMutualRecursionA_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    28;

  void UnsafeArenaSwap(TestMutualRecursionA* other);
  void Swap(TestMutualRecursionA* other);
  friend void swap(TestMutualRecursionA& a, TestMutualRecursionA& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline TestMutualRecursionA* New() const final {
    return CreateMaybeMessage<TestMutualRecursionA>(NULL);
  }

  TestMutualRecursionA* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestMutualRecursionA>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestMutualRecursionA& from);
  void MergeFrom(const TestMutualRecursionA& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TestMutualRecursionA* other);
  protected:
  explicit TestMutualRecursionA(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef TestMutualRecursionA_SubMessage SubMessage;
  typedef TestMutualRecursionA_SubGroup SubGroup;

  // accessors -------------------------------------------------------

  // optional .protobuf_unittest.TestMutualRecursionB bb = 1;
  bool has_bb() const;
  void clear_bb();
  static const int kBbFieldNumber = 1;
  private:
  const ::protobuf_unittest::TestMutualRecursionB& _internal_bb() const;
  public:
  const ::protobuf_unittest::TestMutualRecursionB& bb() const;
  ::protobuf_unittest::TestMutualRecursionB* release_bb();
  ::protobuf_unittest::TestMutualRecursionB* mutable_bb();
  void set_allocated_bb(::protobuf_unittest::TestMutualRecursionB* bb);
  void unsafe_arena_set_allocated_bb(
      ::protobuf_unittest::TestMutualRecursionB* bb);
  ::protobuf_unittest::TestMutualRecursionB* unsafe_arena_release_bb();

  // optional group SubGroup = 2 { ... };
  bool has_subgroup() const;
  void clear_subgroup();
  static const int kSubgroupFieldNumber = 2;
  private:
  const ::protobuf_unittest::TestMutualRecursionA_SubGroup& _internal_subgroup() const;
  public:
  const ::protobuf_unittest::TestMutualRecursionA_SubGroup& subgroup() const;
  ::protobuf_unittest::TestMutualRecursionA_SubGroup* release_subgroup();
  ::protobuf_unittest::TestMutualRecursionA_SubGroup* mutable_subgroup();
  void set_allocated_subgroup(::protobuf_unittest::TestMutualRecursionA_SubGroup* subgroup);
  void unsafe_arena_set_allocated_subgroup(
      ::protobuf_unittest::TestMutualRecursionA_SubGroup* subgroup);
  ::protobuf_unittest::TestMutualRecursionA_SubGroup* unsafe_arena_release_subgroup();

  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestMutualRecursionA)
 private:
  void set_has_bb();
  void clear_has_bb();
  void set_has_subgroup();
  void clear_has_subgroup();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::protobuf_unittest::TestMutualRecursionB* bb_;
  ::protobuf_unittest::TestMutualRecursionA_SubGroup* subgroup_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class TestMutualRecursionB : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.TestMutualRecursionB) */ {
 public:
  TestMutualRecursionB();
  virtual ~TestMutualRecursionB();

  TestMutualRecursionB(const TestMutualRecursionB& from);

  inline TestMutualRecursionB& operator=(const TestMutualRecursionB& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TestMutualRecursionB(TestMutualRecursionB&& from) noexcept
    : TestMutualRecursionB() {
    *this = ::std::move(from);
  }

  inline TestMutualRecursionB& operator=(TestMutualRecursionB&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const TestMutualRecursionB& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TestMutualRecursionB* internal_default_instance() {
    return reinterpret_cast<const TestMutualRecursionB*>(
               &_TestMutualRecursionB_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    29;

  void UnsafeArenaSwap(TestMutualRecursionB* other);
  void Swap(TestMutualRecursionB* other);
  friend void swap(TestMutualRecursionB& a, TestMutualRecursionB& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline TestMutualRecursionB* New() const final {
    return CreateMaybeMessage<TestMutualRecursionB>(NULL);
  }

  TestMutualRecursionB* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestMutualRecursionB>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestMutualRecursionB& from);
  void MergeFrom(const TestMutualRecursionB& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TestMutualRecursionB* other);
  protected:
  explicit TestMutualRecursionB(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .protobuf_unittest.TestMutualRecursionA a = 1;
  bool has_a() const;
  void clear_a();
  static const int kAFieldNumber = 1;
  private:
  const ::protobuf_unittest::TestMutualRecursionA& _internal_a() const;
  public:
  const ::protobuf_unittest::TestMutualRecursionA& a() const;
  ::protobuf_unittest::TestMutualRecursionA* release_a();
  ::protobuf_unittest::TestMutualRecursionA* mutable_a();
  void set_allocated_a(::protobuf_unittest::TestMutualRecursionA* a);
  void unsafe_arena_set_allocated_a(
      ::protobuf_unittest::TestMutualRecursionA* a);
  ::protobuf_unittest::TestMutualRecursionA* unsafe_arena_release_a();

  // optional int32 optional_int32 = 2;
  bool has_optional_int32() const;
  void clear_optional_int32();
  static const int kOptionalInt32FieldNumber = 2;
  ::google::protobuf::int32 optional_int32() const;
  void set_optional_int32(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestMutualRecursionB)
 private:
  void set_has_a();
  void clear_has_a();
  void set_has_optional_int32();
  void clear_has_optional_int32();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::protobuf_unittest::TestMutualRecursionA* a_;
  ::google::protobuf::int32 optional_int32_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class TestIsInitialized_SubMessage_SubGroup : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.TestIsInitialized.SubMessage.SubGroup) */ {
 public:
  TestIsInitialized_SubMessage_SubGroup();
  virtual ~TestIsInitialized_SubMessage_SubGroup();

  TestIsInitialized_SubMessage_SubGroup(const TestIsInitialized_SubMessage_SubGroup& from);

  inline TestIsInitialized_SubMessage_SubGroup& operator=(const TestIsInitialized_SubMessage_SubGroup& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TestIsInitialized_SubMessage_SubGroup(TestIsInitialized_SubMessage_SubGroup&& from) noexcept
    : TestIsInitialized_SubMessage_SubGroup() {
    *this = ::std::move(from);
  }

  inline TestIsInitialized_SubMessage_SubGroup& operator=(TestIsInitialized_SubMessage_SubGroup&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const TestIsInitialized_SubMessage_SubGroup& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TestIsInitialized_SubMessage_SubGroup* internal_default_instance() {
    return reinterpret_cast<const TestIsInitialized_SubMessage_SubGroup*>(
               &_TestIsInitialized_SubMessage_SubGroup_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    30;

  void UnsafeArenaSwap(TestIsInitialized_SubMessage_SubGroup* other);
  void Swap(TestIsInitialized_SubMessage_SubGroup* other);
  friend void swap(TestIsInitialized_SubMessage_SubGroup& a, TestIsInitialized_SubMessage_SubGroup& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline TestIsInitialized_SubMessage_SubGroup* New() const final {
    return CreateMaybeMessage<TestIsInitialized_SubMessage_SubGroup>(NULL);
  }

  TestIsInitialized_SubMessage_SubGroup* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestIsInitialized_SubMessage_SubGroup>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestIsInitialized_SubMessage_SubGroup& from);
  void MergeFrom(const TestIsInitialized_SubMessage_SubGroup& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TestIsInitialized_SubMessage_SubGroup* other);
  protected:
  explicit TestIsInitialized_SubMessage_SubGroup(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // required int32 i = 2;
  bool has_i() const;
  void clear_i();
  static const int kIFieldNumber = 2;
  ::google::protobuf::int32 i() const;
  void set_i(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestIsInitialized.SubMessage.SubGroup)
 private:
  void set_has_i();
  void clear_has_i();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::int32 i_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class TestIsInitialized_SubMessage : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.TestIsInitialized.SubMessage) */ {
 public:
  TestIsInitialized_SubMessage();
  virtual ~TestIsInitialized_SubMessage();

  TestIsInitialized_SubMessage(const TestIsInitialized_SubMessage& from);

  inline TestIsInitialized_SubMessage& operator=(const TestIsInitialized_SubMessage& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TestIsInitialized_SubMessage(TestIsInitialized_SubMessage&& from) noexcept
    : TestIsInitialized_SubMessage() {
    *this = ::std::move(from);
  }

  inline TestIsInitialized_SubMessage& operator=(TestIsInitialized_SubMessage&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const TestIsInitialized_SubMessage& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TestIsInitialized_SubMessage* internal_default_instance() {
    return reinterpret_cast<const TestIsInitialized_SubMessage*>(
               &_TestIsInitialized_SubMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    31;

  void UnsafeArenaSwap(TestIsInitialized_SubMessage* other);
  void Swap(TestIsInitialized_SubMessage* other);
  friend void swap(TestIsInitialized_SubMessage& a, TestIsInitialized_SubMessage& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline TestIsInitialized_SubMessage* New() const final {
    return CreateMaybeMessage<TestIsInitialized_SubMessage>(NULL);
  }

  TestIsInitialized_SubMessage* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestIsInitialized_SubMessage>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestIsInitialized_SubMessage& from);
  void MergeFrom(const TestIsInitialized_SubMessage& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TestIsInitialized_SubMessage* other);
  protected:
  explicit TestIsInitialized_SubMessage(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef TestIsInitialized_SubMessage_SubGroup SubGroup;

  // accessors -------------------------------------------------------

  // optional group SubGroup = 1 { ... };
  bool has_subgroup() const;
  void clear_subgroup();
  static const int kSubgroupFieldNumber = 1;
  private:
  const ::protobuf_unittest::TestIsInitialized_SubMessage_SubGroup& _internal_subgroup() const;
  public:
  const ::protobuf_unittest::TestIsInitialized_SubMessage_SubGroup& subgroup() const;
  ::protobuf_unittest::TestIsInitialized_SubMessage_SubGroup* release_subgroup();
  ::protobuf_unittest::TestIsInitialized_SubMessage_SubGroup* mutable_subgroup();
  void set_allocated_subgroup(::protobuf_unittest::TestIsInitialized_SubMessage_SubGroup* subgroup);
  void unsafe_arena_set_allocated_subgroup(
      ::protobuf_unittest::TestIsInitialized_SubMessage_SubGroup* subgroup);
  ::protobuf_unittest::TestIsInitialized_SubMessage_SubGroup* unsafe_arena_release_subgroup();

  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestIsInitialized.SubMessage)
 private:
  void set_has_subgroup();
  void clear_has_subgroup();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::protobuf_unittest::TestIsInitialized_SubMessage_SubGroup* subgroup_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class TestIsInitialized : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.TestIsInitialized) */ {
 public:
  TestIsInitialized();
  virtual ~TestIsInitialized();

  TestIsInitialized(const TestIsInitialized& from);

  inline TestIsInitialized& operator=(const TestIsInitialized& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TestIsInitialized(TestIsInitialized&& from) noexcept
    : TestIsInitialized() {
    *this = ::std::move(from);
  }

  inline TestIsInitialized& operator=(TestIsInitialized&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const TestIsInitialized& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TestIsInitialized* internal_default_instance() {
    return reinterpret_cast<const TestIsInitialized*>(
               &_TestIsInitialized_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    32;

  void UnsafeArenaSwap(TestIsInitialized* other);
  void Swap(TestIsInitialized* other);
  friend void swap(TestIsInitialized& a, TestIsInitialized& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline TestIsInitialized* New() const final {
    return CreateMaybeMessage<TestIsInitialized>(NULL);
  }

  TestIsInitialized* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestIsInitialized>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestIsInitialized& from);
  void MergeFrom(const TestIsInitialized& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TestIsInitialized* other);
  protected:
  explicit TestIsInitialized(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef TestIsInitialized_SubMessage SubMessage;

  // accessors -------------------------------------------------------

  // optional .protobuf_unittest.TestIsInitialized.SubMessage sub_message = 1;
  bool has_sub_message() const;
  void clear_sub_message();
  static const int kSubMessageFieldNumber = 1;
  private:
  const ::protobuf_unittest::TestIsInitialized_SubMessage& _internal_sub_message() const;
  public:
  const ::protobuf_unittest::TestIsInitialized_SubMessage& sub_message() const;
  ::protobuf_unittest::TestIsInitialized_SubMessage* release_sub_message();
  ::protobuf_unittest::TestIsInitialized_SubMessage* mutable_sub_message();
  void set_allocated_sub_message(::protobuf_unittest::TestIsInitialized_SubMessage* sub_message);
  void unsafe_arena_set_allocated_sub_message(
      ::protobuf_unittest::TestIsInitialized_SubMessage* sub_message);
  ::protobuf_unittest::TestIsInitialized_SubMessage* unsafe_arena_release_sub_message();

  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestIsInitialized)
 private:
  void set_has_sub_message();
  void clear_has_sub_message();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::protobuf_unittest::TestIsInitialized_SubMessage* sub_message_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class TestDupFieldNumber_Foo : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.TestDupFieldNumber.Foo) */ {
 public:
  TestDupFieldNumber_Foo();
  virtual ~TestDupFieldNumber_Foo();

  TestDupFieldNumber_Foo(const TestDupFieldNumber_Foo& from);

  inline TestDupFieldNumber_Foo& operator=(const TestDupFieldNumber_Foo& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TestDupFieldNumber_Foo(TestDupFieldNumber_Foo&& from) noexcept
    : TestDupFieldNumber_Foo() {
    *this = ::std::move(from);
  }

  inline TestDupFieldNumber_Foo& operator=(TestDupFieldNumber_Foo&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const TestDupFieldNumber_Foo& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TestDupFieldNumber_Foo* internal_default_instance() {
    return reinterpret_cast<const TestDupFieldNumber_Foo*>(
               &_TestDupFieldNumber_Foo_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    33;

  void UnsafeArenaSwap(TestDupFieldNumber_Foo* other);
  void Swap(TestDupFieldNumber_Foo* other);
  friend void swap(TestDupFieldNumber_Foo& a, TestDupFieldNumber_Foo& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline TestDupFieldNumber_Foo* New() const final {
    return CreateMaybeMessage<TestDupFieldNumber_Foo>(NULL);
  }

  TestDupFieldNumber_Foo* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestDupFieldNumber_Foo>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestDupFieldNumber_Foo& from);
  void MergeFrom(const TestDupFieldNumber_Foo& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TestDupFieldNumber_Foo* other);
  protected:
  explicit TestDupFieldNumber_Foo(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional int32 a = 1;
  bool has_a() const;
  void clear_a();
  static const int kAFieldNumber = 1;
  ::google::protobuf::int32 a() const;
  void set_a(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestDupFieldNumber.Foo)
 private:
  void set_has_a();
  void clear_has_a();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::int32 a_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class TestDupFieldNumber_Bar : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.TestDupFieldNumber.Bar) */ {
 public:
  TestDupFieldNumber_Bar();
  virtual ~TestDupFieldNumber_Bar();

  TestDupFieldNumber_Bar(const TestDupFieldNumber_Bar& from);

  inline TestDupFieldNumber_Bar& operator=(const TestDupFieldNumber_Bar& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TestDupFieldNumber_Bar(TestDupFieldNumber_Bar&& from) noexcept
    : TestDupFieldNumber_Bar() {
    *this = ::std::move(from);
  }

  inline TestDupFieldNumber_Bar& operator=(TestDupFieldNumber_Bar&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const TestDupFieldNumber_Bar& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TestDupFieldNumber_Bar* internal_default_instance() {
    return reinterpret_cast<const TestDupFieldNumber_Bar*>(
               &_TestDupFieldNumber_Bar_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    34;

  void UnsafeArenaSwap(TestDupFieldNumber_Bar* other);
  void Swap(TestDupFieldNumber_Bar* other);
  friend void swap(TestDupFieldNumber_Bar& a, TestDupFieldNumber_Bar& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline TestDupFieldNumber_Bar* New() const final {
    return CreateMaybeMessage<TestDupFieldNumber_Bar>(NULL);
  }

  TestDupFieldNumber_Bar* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestDupFieldNumber_Bar>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestDupFieldNumber_Bar& from);
  void MergeFrom(const TestDupFieldNumber_Bar& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TestDupFieldNumber_Bar* other);
  protected:
  explicit TestDupFieldNumber_Bar(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional int32 a = 1;
  bool has_a() const;
  void clear_a();
  static const int kAFieldNumber = 1;
  ::google::protobuf::int32 a() const;
  void set_a(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestDupFieldNumber.Bar)
 private:
  void set_has_a();
  void clear_has_a();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::int32 a_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class TestDupFieldNumber : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.TestDupFieldNumber) */ {
 public:
  TestDupFieldNumber();
  virtual ~TestDupFieldNumber();

  TestDupFieldNumber(const TestDupFieldNumber& from);

  inline TestDupFieldNumber& operator=(const TestDupFieldNumber& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TestDupFieldNumber(TestDupFieldNumber&& from) noexcept
    : TestDupFieldNumber() {
    *this = ::std::move(from);
  }

  inline TestDupFieldNumber& operator=(TestDupFieldNumber&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const TestDupFieldNumber& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TestDupFieldNumber* internal_default_instance() {
    return reinterpret_cast<const TestDupFieldNumber*>(
               &_TestDupFieldNumber_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    35;

  void UnsafeArenaSwap(TestDupFieldNumber* other);
  void Swap(TestDupFieldNumber* other);
  friend void swap(TestDupFieldNumber& a, TestDupFieldNumber& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline TestDupFieldNumber* New() const final {
    return CreateMaybeMessage<TestDupFieldNumber>(NULL);
  }

  TestDupFieldNumber* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestDupFieldNumber>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestDupFieldNumber& from);
  void MergeFrom(const TestDupFieldNumber& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TestDupFieldNumber* other);
  protected:
  explicit TestDupFieldNumber(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef TestDupFieldNumber_Foo Foo;
  typedef TestDupFieldNumber_Bar Bar;

  // accessors -------------------------------------------------------

  // optional group Foo = 2 { ... };
  bool has_foo() const;
  void clear_foo();
  static const int kFooFieldNumber = 2;
  private:
  const ::protobuf_unittest::TestDupFieldNumber_Foo& _internal_foo() const;
  public:
  const ::protobuf_unittest::TestDupFieldNumber_Foo& foo() const;
  ::protobuf_unittest::TestDupFieldNumber_Foo* release_foo();
  ::protobuf_unittest::TestDupFieldNumber_Foo* mutable_foo();
  void set_allocated_foo(::protobuf_unittest::TestDupFieldNumber_Foo* foo);
  void unsafe_arena_set_allocated_foo(
      ::protobuf_unittest::TestDupFieldNumber_Foo* foo);
  ::protobuf_unittest::TestDupFieldNumber_Foo* unsafe_arena_release_foo();

  // optional group Bar = 3 { ... };
  bool has_bar() const;
  void clear_bar();
  static const int kBarFieldNumber = 3;
  private:
  const ::protobuf_unittest::TestDupFieldNumber_Bar& _internal_bar() const;
  public:
  const ::protobuf_unittest::TestDupFieldNumber_Bar& bar() const;
  ::protobuf_unittest::TestDupFieldNumber_Bar* release_bar();
  ::protobuf_unittest::TestDupFieldNumber_Bar* mutable_bar();
  void set_allocated_bar(::protobuf_unittest::TestDupFieldNumber_Bar* bar);
  void unsafe_arena_set_allocated_bar(
      ::protobuf_unittest::TestDupFieldNumber_Bar* bar);
  ::protobuf_unittest::TestDupFieldNumber_Bar* unsafe_arena_release_bar();

  // optional int32 a = 1;
  bool has_a() const;
  void clear_a();
  static const int kAFieldNumber = 1;
  ::google::protobuf::int32 a() const;
  void set_a(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestDupFieldNumber)
 private:
  void set_has_a();
  void clear_has_a();
  void set_has_foo();
  void clear_has_foo();
  void set_has_bar();
  void clear_has_bar();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::protobuf_unittest::TestDupFieldNumber_Foo* foo_;
  ::protobuf_unittest::TestDupFieldNumber_Bar* bar_;
  ::google::protobuf::int32 a_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class TestEagerMessage : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.TestEagerMessage) */ {
 public:
  TestEagerMessage();
  virtual ~TestEagerMessage();

  TestEagerMessage(const TestEagerMessage& from);

  inline TestEagerMessage& operator=(const TestEagerMessage& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TestEagerMessage(TestEagerMessage&& from) noexcept
    : TestEagerMessage() {
    *this = ::std::move(from);
  }

  inline TestEagerMessage& operator=(TestEagerMessage&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const TestEagerMessage& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TestEagerMessage* internal_default_instance() {
    return reinterpret_cast<const TestEagerMessage*>(
               &_TestEagerMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    36;

  void UnsafeArenaSwap(TestEagerMessage* other);
  void Swap(TestEagerMessage* other);
  friend void swap(TestEagerMessage& a, TestEagerMessage& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline TestEagerMessage* New() const final {
    return CreateMaybeMessage<TestEagerMessage>(NULL);
  }

  TestEagerMessage* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestEagerMessage>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestEagerMessage& from);
  void MergeFrom(const TestEagerMessage& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TestEagerMessage* other);
  protected:
  explicit TestEagerMessage(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .protobuf_unittest.TestAllTypes sub_message = 1 [lazy = false];
  bool has_sub_message() const;
  void clear_sub_message();
  static const int kSubMessageFieldNumber = 1;
  private:
  const ::protobuf_unittest::TestAllTypes& _internal_sub_message() const;
  public:
  const ::protobuf_unittest::TestAllTypes& sub_message() const;
  ::protobuf_unittest::TestAllTypes* release_sub_message();
  ::protobuf_unittest::TestAllTypes* mutable_sub_message();
  void set_allocated_sub_message(::protobuf_unittest::TestAllTypes* sub_message);
  void unsafe_arena_set_allocated_sub_message(
      ::protobuf_unittest::TestAllTypes* sub_message);
  ::protobuf_unittest::TestAllTypes* unsafe_arena_release_sub_message();

  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestEagerMessage)
 private:
  void set_has_sub_message();
  void clear_has_sub_message();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::protobuf_unittest::TestAllTypes* sub_message_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class TestLazyMessage : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.TestLazyMessage) */ {
 public:
  TestLazyMessage();
  virtual ~TestLazyMessage();

  TestLazyMessage(const TestLazyMessage& from);

  inline TestLazyMessage& operator=(const TestLazyMessage& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TestLazyMessage(TestLazyMessage&& from) noexcept
    : TestLazyMessage() {
    *this = ::std::move(from);
  }

  inline TestLazyMessage& operator=(TestLazyMessage&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const TestLazyMessage& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TestLazyMessage* internal_default_instance() {
    return reinterpret_cast<const TestLazyMessage*>(
               &_TestLazyMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    37;

  void UnsafeArenaSwap(TestLazyMessage* other);
  void Swap(TestLazyMessage* other);
  friend void swap(TestLazyMessage& a, TestLazyMessage& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline TestLazyMessage* New() const final {
    return CreateMaybeMessage<TestLazyMessage>(NULL);
  }

  TestLazyMessage* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestLazyMessage>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestLazyMessage& from);
  void MergeFrom(const TestLazyMessage& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TestLazyMessage* other);
  protected:
  explicit TestLazyMessage(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .protobuf_unittest.TestAllTypes sub_message = 1 [lazy = true];
  bool has_sub_message() const;
  void clear_sub_message();
  static const int kSubMessageFieldNumber = 1;
  private:
  const ::protobuf_unittest::TestAllTypes& _internal_sub_message() const;
  public:
  const ::protobuf_unittest::TestAllTypes& sub_message() const;
  ::protobuf_unittest::TestAllTypes* release_sub_message();
  ::protobuf_unittest::TestAllTypes* mutable_sub_message();
  void set_allocated_sub_message(::protobuf_unittest::TestAllTypes* sub_message);
  void unsafe_arena_set_allocated_sub_message(
      ::protobuf_unittest::TestAllTypes* sub_message);
  ::protobuf_unittest::TestAllTypes* unsafe_arena_release_sub_message();

  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestLazyMessage)
 private:
  void set_has_sub_message();
  void clear_has_sub_message();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::protobuf_unittest::TestAllTypes* sub_message_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class TestNestedMessageHasBits_NestedMessage : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.TestNestedMessageHasBits.NestedMessage) */ {
 public:
  TestNestedMessageHasBits_NestedMessage();
  virtual ~TestNestedMessageHasBits_NestedMessage();

  TestNestedMessageHasBits_NestedMessage(const TestNestedMessageHasBits_NestedMessage& from);

  inline TestNestedMessageHasBits_NestedMessage& operator=(const TestNestedMessageHasBits_NestedMessage& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TestNestedMessageHasBits_NestedMessage(TestNestedMessageHasBits_NestedMessage&& from) noexcept
    : TestNestedMessageHasBits_NestedMessage() {
    *this = ::std::move(from);
  }

  inline TestNestedMessageHasBits_NestedMessage& operator=(TestNestedMessageHasBits_NestedMessage&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const TestNestedMessageHasBits_NestedMessage& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TestNestedMessageHasBits_NestedMessage* internal_default_instance() {
    return reinterpret_cast<const TestNestedMessageHasBits_NestedMessage*>(
               &_TestNestedMessageHasBits_NestedMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    38;

  void UnsafeArenaSwap(TestNestedMessageHasBits_NestedMessage* other);
  void Swap(TestNestedMessageHasBits_NestedMessage* other);
  friend void swap(TestNestedMessageHasBits_NestedMessage& a, TestNestedMessageHasBits_NestedMessage& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline TestNestedMessageHasBits_NestedMessage* New() const final {
    return CreateMaybeMessage<TestNestedMessageHasBits_NestedMessage>(NULL);
  }

  TestNestedMessageHasBits_NestedMessage* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestNestedMessageHasBits_NestedMessage>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestNestedMessageHasBits_NestedMessage& from);
  void MergeFrom(const TestNestedMessageHasBits_NestedMessage& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TestNestedMessageHasBits_NestedMessage* other);
  protected:
  explicit TestNestedMessageHasBits_NestedMessage(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated int32 nestedmessage_repeated_int32 = 1;
  int nestedmessage_repeated_int32_size() const;
  void clear_nestedmessage_repeated_int32();
  static const int kNestedmessageRepeatedInt32FieldNumber = 1;
  ::google::protobuf::int32 nestedmessage_repeated_int32(int index) const;
  void set_nestedmessage_repeated_int32(int index, ::google::protobuf::int32 value);
  void add_nestedmessage_repeated_int32(::google::protobuf::int32 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
      nestedmessage_repeated_int32() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
      mutable_nestedmessage_repeated_int32();

  // repeated .protobuf_unittest.ForeignMessage nestedmessage_repeated_foreignmessage = 2;
  int nestedmessage_repeated_foreignmessage_size() const;
  void clear_nestedmessage_repeated_foreignmessage();
  static const int kNestedmessageRepeatedForeignmessageFieldNumber = 2;
  ::protobuf_unittest::ForeignMessage* mutable_nestedmessage_repeated_foreignmessage(int index);
  ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::ForeignMessage >*
      mutable_nestedmessage_repeated_foreignmessage();
  const ::protobuf_unittest::ForeignMessage& nestedmessage_repeated_foreignmessage(int index) const;
  ::protobuf_unittest::ForeignMessage* add_nestedmessage_repeated_foreignmessage();
  const ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::ForeignMessage >&
      nestedmessage_repeated_foreignmessage() const;

  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestNestedMessageHasBits.NestedMessage)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > nestedmessage_repeated_int32_;
  ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::ForeignMessage > nestedmessage_repeated_foreignmessage_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class TestNestedMessageHasBits : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.TestNestedMessageHasBits) */ {
 public:
  TestNestedMessageHasBits();
  virtual ~TestNestedMessageHasBits();

  TestNestedMessageHasBits(const TestNestedMessageHasBits& from);

  inline TestNestedMessageHasBits& operator=(const TestNestedMessageHasBits& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TestNestedMessageHasBits(TestNestedMessageHasBits&& from) noexcept
    : TestNestedMessageHasBits() {
    *this = ::std::move(from);
  }

  inline TestNestedMessageHasBits& operator=(TestNestedMessageHasBits&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const TestNestedMessageHasBits& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TestNestedMessageHasBits* internal_default_instance() {
    return reinterpret_cast<const TestNestedMessageHasBits*>(
               &_TestNestedMessageHasBits_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    39;

  void UnsafeArenaSwap(TestNestedMessageHasBits* other);
  void Swap(TestNestedMessageHasBits* other);
  friend void swap(TestNestedMessageHasBits& a, TestNestedMessageHasBits& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline TestNestedMessageHasBits* New() const final {
    return CreateMaybeMessage<TestNestedMessageHasBits>(NULL);
  }

  TestNestedMessageHasBits* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestNestedMessageHasBits>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestNestedMessageHasBits& from);
  void MergeFrom(const TestNestedMessageHasBits& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TestNestedMessageHasBits* other);
  protected:
  explicit TestNestedMessageHasBits(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef TestNestedMessageHasBits_NestedMessage NestedMessage;

  // accessors -------------------------------------------------------

  // optional .protobuf_unittest.TestNestedMessageHasBits.NestedMessage optional_nested_message = 1;
  bool has_optional_nested_message() const;
  void clear_optional_nested_message();
  static const int kOptionalNestedMessageFieldNumber = 1;
  private:
  const ::protobuf_unittest::TestNestedMessageHasBits_NestedMessage& _internal_optional_nested_message() const;
  public:
  const ::protobuf_unittest::TestNestedMessageHasBits_NestedMessage& optional_nested_message() const;
  ::protobuf_unittest::TestNestedMessageHasBits_NestedMessage* release_optional_nested_message();
  ::protobuf_unittest::TestNestedMessageHasBits_NestedMessage* mutable_optional_nested_message();
  void set_allocated_optional_nested_message(::protobuf_unittest::TestNestedMessageHasBits_NestedMessage* optional_nested_message);
  void unsafe_arena_set_allocated_optional_nested_message(
      ::protobuf_unittest::TestNestedMessageHasBits_NestedMessage* optional_nested_message);
  ::protobuf_unittest::TestNestedMessageHasBits_NestedMessage* unsafe_arena_release_optional_nested_message();

  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestNestedMessageHasBits)
 private:
  void set_has_optional_nested_message();
  void clear_has_optional_nested_message();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::protobuf_unittest::TestNestedMessageHasBits_NestedMessage* optional_nested_message_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class TestCamelCaseFieldNames : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.TestCamelCaseFieldNames) */ {
 public:
  TestCamelCaseFieldNames();
  virtual ~TestCamelCaseFieldNames();

  TestCamelCaseFieldNames(const TestCamelCaseFieldNames& from);

  inline TestCamelCaseFieldNames& operator=(const TestCamelCaseFieldNames& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TestCamelCaseFieldNames(TestCamelCaseFieldNames&& from) noexcept
    : TestCamelCaseFieldNames() {
    *this = ::std::move(from);
  }

  inline TestCamelCaseFieldNames& operator=(TestCamelCaseFieldNames&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const TestCamelCaseFieldNames& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TestCamelCaseFieldNames* internal_default_instance() {
    return reinterpret_cast<const TestCamelCaseFieldNames*>(
               &_TestCamelCaseFieldNames_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    40;

  void UnsafeArenaSwap(TestCamelCaseFieldNames* other);
  void Swap(TestCamelCaseFieldNames* other);
  friend void swap(TestCamelCaseFieldNames& a, TestCamelCaseFieldNames& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline TestCamelCaseFieldNames* New() const final {
    return CreateMaybeMessage<TestCamelCaseFieldNames>(NULL);
  }

  TestCamelCaseFieldNames* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestCamelCaseFieldNames>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestCamelCaseFieldNames& from);
  void MergeFrom(const TestCamelCaseFieldNames& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TestCamelCaseFieldNames* other);
  protected:
  explicit TestCamelCaseFieldNames(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated int32 RepeatedPrimitiveField = 7;
  int repeatedprimitivefield_size() const;
  void clear_repeatedprimitivefield();
  static const int kRepeatedPrimitiveFieldFieldNumber = 7;
  ::google::protobuf::int32 repeatedprimitivefield(int index) const;
  void set_repeatedprimitivefield(int index, ::google::protobuf::int32 value);
  void add_repeatedprimitivefield(::google::protobuf::int32 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
      repeatedprimitivefield() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
      mutable_repeatedprimitivefield();

  // repeated string RepeatedStringField = 8;
  int repeatedstringfield_size() const;
  void clear_repeatedstringfield();
  static const int kRepeatedStringFieldFieldNumber = 8;
  const ::std::string& repeatedstringfield(int index) const;
  ::std::string* mutable_repeatedstringfield(int index);
  void set_repeatedstringfield(int index, const ::std::string& value);
  #if LANG_CXX11
  void set_repeatedstringfield(int index, ::std::string&& value);
  #endif
  void set_repeatedstringfield(int index, const char* value);
  void set_repeatedstringfield(int index, const char* value, size_t size);
  ::std::string* add_repeatedstringfield();
  void add_repeatedstringfield(const ::std::string& value);
  #if LANG_CXX11
  void add_repeatedstringfield(::std::string&& value);
  #endif
  void add_repeatedstringfield(const char* value);
  void add_repeatedstringfield(const char* value, size_t size);
  const ::google::protobuf::RepeatedPtrField< ::std::string>& repeatedstringfield() const;
  ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_repeatedstringfield();

  // repeated .protobuf_unittest.ForeignEnum RepeatedEnumField = 9;
  int repeatedenumfield_size() const;
  void clear_repeatedenumfield();
  static const int kRepeatedEnumFieldFieldNumber = 9;
  ::protobuf_unittest::ForeignEnum repeatedenumfield(int index) const;
  void set_repeatedenumfield(int index, ::protobuf_unittest::ForeignEnum value);
  void add_repeatedenumfield(::protobuf_unittest::ForeignEnum value);
  const ::google::protobuf::RepeatedField<int>& repeatedenumfield() const;
  ::google::protobuf::RepeatedField<int>* mutable_repeatedenumfield();

  // repeated .protobuf_unittest.ForeignMessage RepeatedMessageField = 10;
  int repeatedmessagefield_size() const;
  void clear_repeatedmessagefield();
  static const int kRepeatedMessageFieldFieldNumber = 10;
  ::protobuf_unittest::ForeignMessage* mutable_repeatedmessagefield(int index);
  ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::ForeignMessage >*
      mutable_repeatedmessagefield();
  const ::protobuf_unittest::ForeignMessage& repeatedmessagefield(int index) const;
  ::protobuf_unittest::ForeignMessage* add_repeatedmessagefield();
  const ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::ForeignMessage >&
      repeatedmessagefield() const;

  // repeated string RepeatedStringPieceField = 11 [ctype = STRING_PIECE];
  int repeatedstringpiecefield_size() const;
  void clear_repeatedstringpiecefield();
  static const int kRepeatedStringPieceFieldFieldNumber = 11;
 private:
  // Hidden due to unknown ctype option.
  const ::std::string& repeatedstringpiecefield(int index) const;
  ::std::string* mutable_repeatedstringpiecefield(int index);
  void set_repeatedstringpiecefield(int index, const ::std::string& value);
  #if LANG_CXX11
  void set_repeatedstringpiecefield(int index, ::std::string&& value);
  #endif
  void set_repeatedstringpiecefield(int index, const char* value);
  void set_repeatedstringpiecefield(int index, const char* value, size_t size);
  ::std::string* add_repeatedstringpiecefield();
  void add_repeatedstringpiecefield(const ::std::string& value);
  #if LANG_CXX11
  void add_repeatedstringpiecefield(::std::string&& value);
  #endif
  void add_repeatedstringpiecefield(const char* value);
  void add_repeatedstringpiecefield(const char* value, size_t size);
  const ::google::protobuf::RepeatedPtrField< ::std::string>& repeatedstringpiecefield() const;
  ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_repeatedstringpiecefield();
 public:

  // repeated string RepeatedCordField = 12 [ctype = CORD];
  int repeatedcordfield_size() const;
  void clear_repeatedcordfield();
  static const int kRepeatedCordFieldFieldNumber = 12;
 private:
  // Hidden due to unknown ctype option.
  const ::std::string& repeatedcordfield(int index) const;
  ::std::string* mutable_repeatedcordfield(int index);
  void set_repeatedcordfield(int index, const ::std::string& value);
  #if LANG_CXX11
  void set_repeatedcordfield(int index, ::std::string&& value);
  #endif
  void set_repeatedcordfield(int index, const char* value);
  void set_repeatedcordfield(int index, const char* value, size_t size);
  ::std::string* add_repeatedcordfield();
  void add_repeatedcordfield(const ::std::string& value);
  #if LANG_CXX11
  void add_repeatedcordfield(::std::string&& value);
  #endif
  void add_repeatedcordfield(const char* value);
  void add_repeatedcordfield(const char* value, size_t size);
  const ::google::protobuf::RepeatedPtrField< ::std::string>& repeatedcordfield() const;
  ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_repeatedcordfield();
 public:

  // optional string StringField = 2;
  bool has_stringfield() const;
  void clear_stringfield();
  static const int kStringFieldFieldNumber = 2;
  const ::std::string& stringfield() const;
  void set_stringfield(const ::std::string& value);
  #if LANG_CXX11
  void set_stringfield(::std::string&& value);
  #endif
  void set_stringfield(const char* value);
  void set_stringfield(const char* value, size_t size);
  ::std::string* mutable_stringfield();
  ::std::string* release_stringfield();
  void set_allocated_stringfield(::std::string* stringfield);
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  ::std::string* unsafe_arena_release_stringfield();
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  void unsafe_arena_set_allocated_stringfield(
      ::std::string* stringfield);

  // optional string StringPieceField = 5 [ctype = STRING_PIECE];
  bool has_stringpiecefield() const;
  void clear_stringpiecefield();
  static const int kStringPieceFieldFieldNumber = 5;
 private:
  // Hidden due to unknown ctype option.
  const ::std::string& stringpiecefield() const;
  void set_stringpiecefield(const ::std::string& value);
  #if LANG_CXX11
  void set_stringpiecefield(::std::string&& value);
  #endif
  void set_stringpiecefield(const char* value);
  void set_stringpiecefield(const char* value, size_t size);
  ::std::string* mutable_stringpiecefield();
  ::std::string* release_stringpiecefield();
  void set_allocated_stringpiecefield(::std::string* stringpiecefield);
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  ::std::string* unsafe_arena_release_stringpiecefield();
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  void unsafe_arena_set_allocated_stringpiecefield(
      ::std::string* stringpiecefield);
 public:

  // optional string CordField = 6 [ctype = CORD];
  bool has_cordfield() const;
  void clear_cordfield();
  static const int kCordFieldFieldNumber = 6;
 private:
  // Hidden due to unknown ctype option.
  const ::std::string& cordfield() const;
  void set_cordfield(const ::std::string& value);
  #if LANG_CXX11
  void set_cordfield(::std::string&& value);
  #endif
  void set_cordfield(const char* value);
  void set_cordfield(const char* value, size_t size);
  ::std::string* mutable_cordfield();
  ::std::string* release_cordfield();
  void set_allocated_cordfield(::std::string* cordfield);
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  ::std::string* unsafe_arena_release_cordfield();
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  void unsafe_arena_set_allocated_cordfield(
      ::std::string* cordfield);
 public:

  // optional .protobuf_unittest.ForeignMessage MessageField = 4;
  bool has_messagefield() const;
  void clear_messagefield();
  static const int kMessageFieldFieldNumber = 4;
  private:
  const ::protobuf_unittest::ForeignMessage& _internal_messagefield() const;
  public:
  const ::protobuf_unittest::ForeignMessage& messagefield() const;
  ::protobuf_unittest::ForeignMessage* release_messagefield();
  ::protobuf_unittest::ForeignMessage* mutable_messagefield();
  void set_allocated_messagefield(::protobuf_unittest::ForeignMessage* messagefield);
  void unsafe_arena_set_allocated_messagefield(
      ::protobuf_unittest::ForeignMessage* messagefield);
  ::protobuf_unittest::ForeignMessage* unsafe_arena_release_messagefield();

  // optional int32 PrimitiveField = 1;
  bool has_primitivefield() const;
  void clear_primitivefield();
  static const int kPrimitiveFieldFieldNumber = 1;
  ::google::protobuf::int32 primitivefield() const;
  void set_primitivefield(::google::protobuf::int32 value);

  // optional .protobuf_unittest.ForeignEnum EnumField = 3;
  bool has_enumfield() const;
  void clear_enumfield();
  static const int kEnumFieldFieldNumber = 3;
  ::protobuf_unittest::ForeignEnum enumfield() const;
  void set_enumfield(::protobuf_unittest::ForeignEnum value);

  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestCamelCaseFieldNames)
 private:
  void set_has_primitivefield();
  void clear_has_primitivefield();
  void set_has_stringfield();
  void clear_has_stringfield();
  void set_has_enumfield();
  void clear_has_enumfield();
  void set_has_messagefield();
  void clear_has_messagefield();
  void set_has_stringpiecefield();
  void clear_has_stringpiecefield();
  void set_has_cordfield();
  void clear_has_cordfield();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > repeatedprimitivefield_;
  ::google::protobuf::RepeatedPtrField< ::std::string> repeatedstringfield_;
  ::google::protobuf::RepeatedField<int> repeatedenumfield_;
  ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::ForeignMessage > repeatedmessagefield_;
  ::google::protobuf::RepeatedPtrField< ::std::string> repeatedstringpiecefield_;
  ::google::protobuf::RepeatedPtrField< ::std::string> repeatedcordfield_;
  ::google::protobuf::internal::ArenaStringPtr stringfield_;
  ::google::protobuf::internal::ArenaStringPtr stringpiecefield_;
  ::google::protobuf::internal::ArenaStringPtr cordfield_;
  ::protobuf_unittest::ForeignMessage* messagefield_;
  ::google::protobuf::int32 primitivefield_;
  int enumfield_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class TestFieldOrderings_NestedMessage : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.TestFieldOrderings.NestedMessage) */ {
 public:
  TestFieldOrderings_NestedMessage();
  virtual ~TestFieldOrderings_NestedMessage();

  TestFieldOrderings_NestedMessage(const TestFieldOrderings_NestedMessage& from);

  inline TestFieldOrderings_NestedMessage& operator=(const TestFieldOrderings_NestedMessage& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TestFieldOrderings_NestedMessage(TestFieldOrderings_NestedMessage&& from) noexcept
    : TestFieldOrderings_NestedMessage() {
    *this = ::std::move(from);
  }

  inline TestFieldOrderings_NestedMessage& operator=(TestFieldOrderings_NestedMessage&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const TestFieldOrderings_NestedMessage& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TestFieldOrderings_NestedMessage* internal_default_instance() {
    return reinterpret_cast<const TestFieldOrderings_NestedMessage*>(
               &_TestFieldOrderings_NestedMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    41;

  void UnsafeArenaSwap(TestFieldOrderings_NestedMessage* other);
  void Swap(TestFieldOrderings_NestedMessage* other);
  friend void swap(TestFieldOrderings_NestedMessage& a, TestFieldOrderings_NestedMessage& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline TestFieldOrderings_NestedMessage* New() const final {
    return CreateMaybeMessage<TestFieldOrderings_NestedMessage>(NULL);
  }

  TestFieldOrderings_NestedMessage* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestFieldOrderings_NestedMessage>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestFieldOrderings_NestedMessage& from);
  void MergeFrom(const TestFieldOrderings_NestedMessage& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TestFieldOrderings_NestedMessage* other);
  protected:
  explicit TestFieldOrderings_NestedMessage(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional int64 oo = 2;
  bool has_oo() const;
  void clear_oo();
  static const int kOoFieldNumber = 2;
  ::google::protobuf::int64 oo() const;
  void set_oo(::google::protobuf::int64 value);

  // optional int32 bb = 1;
  bool has_bb() const;
  void clear_bb();
  static const int kBbFieldNumber = 1;
  ::google::protobuf::int32 bb() const;
  void set_bb(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestFieldOrderings.NestedMessage)
 private:
  void set_has_oo();
  void clear_has_oo();
  void set_has_bb();
  void clear_has_bb();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::int64 oo_;
  ::google::protobuf::int32 bb_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class TestFieldOrderings : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.TestFieldOrderings) */ {
 public:
  TestFieldOrderings();
  virtual ~TestFieldOrderings();

  TestFieldOrderings(const TestFieldOrderings& from);

  inline TestFieldOrderings& operator=(const TestFieldOrderings& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TestFieldOrderings(TestFieldOrderings&& from) noexcept
    : TestFieldOrderings() {
    *this = ::std::move(from);
  }

  inline TestFieldOrderings& operator=(TestFieldOrderings&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const TestFieldOrderings& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TestFieldOrderings* internal_default_instance() {
    return reinterpret_cast<const TestFieldOrderings*>(
               &_TestFieldOrderings_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    42;

  void UnsafeArenaSwap(TestFieldOrderings* other);
  void Swap(TestFieldOrderings* other);
  friend void swap(TestFieldOrderings& a, TestFieldOrderings& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline TestFieldOrderings* New() const final {
    return CreateMaybeMessage<TestFieldOrderings>(NULL);
  }

  TestFieldOrderings* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestFieldOrderings>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestFieldOrderings& from);
  void MergeFrom(const TestFieldOrderings& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TestFieldOrderings* other);
  protected:
  explicit TestFieldOrderings(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef TestFieldOrderings_NestedMessage NestedMessage;

  // accessors -------------------------------------------------------

  // optional string my_string = 11;
  bool has_my_string() const;
  void clear_my_string();
  static const int kMyStringFieldNumber = 11;
  const ::std::string& my_string() const;
  void set_my_string(const ::std::string& value);
  #if LANG_CXX11
  void set_my_string(::std::string&& value);
  #endif
  void set_my_string(const char* value);
  void set_my_string(const char* value, size_t size);
  ::std::string* mutable_my_string();
  ::std::string* release_my_string();
  void set_allocated_my_string(::std::string* my_string);
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  ::std::string* unsafe_arena_release_my_string();
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  void unsafe_arena_set_allocated_my_string(
      ::std::string* my_string);

  // optional .protobuf_unittest.TestFieldOrderings.NestedMessage optional_nested_message = 200;
  bool has_optional_nested_message() const;
  void clear_optional_nested_message();
  static const int kOptionalNestedMessageFieldNumber = 200;
  private:
  const ::protobuf_unittest::TestFieldOrderings_NestedMessage& _internal_optional_nested_message() const;
  public:
  const ::protobuf_unittest::TestFieldOrderings_NestedMessage& optional_nested_message() const;
  ::protobuf_unittest::TestFieldOrderings_NestedMessage* release_optional_nested_message();
  ::protobuf_unittest::TestFieldOrderings_NestedMessage* mutable_optional_nested_message();
  void set_allocated_optional_nested_message(::protobuf_unittest::TestFieldOrderings_NestedMessage* optional_nested_message);
  void unsafe_arena_set_allocated_optional_nested_message(
      ::protobuf_unittest::TestFieldOrderings_NestedMessage* optional_nested_message);
  ::protobuf_unittest::TestFieldOrderings_NestedMessage* unsafe_arena_release_optional_nested_message();

  // optional int64 my_int = 1;
  bool has_my_int() const;
  void clear_my_int();
  static const int kMyIntFieldNumber = 1;
  ::google::protobuf::int64 my_int() const;
  void set_my_int(::google::protobuf::int64 value);

  // optional float my_float = 101;
  bool has_my_float() const;
  void clear_my_float();
  static const int kMyFloatFieldNumber = 101;
  float my_float() const;
  void set_my_float(float value);

  GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(TestFieldOrderings)
  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestFieldOrderings)
 private:
  void set_has_my_string();
  void clear_has_my_string();
  void set_has_my_int();
  void clear_has_my_int();
  void set_has_my_float();
  void clear_has_my_float();
  void set_has_optional_nested_message();
  void clear_has_optional_nested_message();

  ::google::protobuf::internal::ExtensionSet _extensions_;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr my_string_;
  ::protobuf_unittest::TestFieldOrderings_NestedMessage* optional_nested_message_;
  ::google::protobuf::int64 my_int_;
  float my_float_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class TestExtensionOrderings1 : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.TestExtensionOrderings1) */ {
 public:
  TestExtensionOrderings1();
  virtual ~TestExtensionOrderings1();

  TestExtensionOrderings1(const TestExtensionOrderings1& from);

  inline TestExtensionOrderings1& operator=(const TestExtensionOrderings1& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TestExtensionOrderings1(TestExtensionOrderings1&& from) noexcept
    : TestExtensionOrderings1() {
    *this = ::std::move(from);
  }

  inline TestExtensionOrderings1& operator=(TestExtensionOrderings1&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const TestExtensionOrderings1& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TestExtensionOrderings1* internal_default_instance() {
    return reinterpret_cast<const TestExtensionOrderings1*>(
               &_TestExtensionOrderings1_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    43;

  void UnsafeArenaSwap(TestExtensionOrderings1* other);
  void Swap(TestExtensionOrderings1* other);
  friend void swap(TestExtensionOrderings1& a, TestExtensionOrderings1& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline TestExtensionOrderings1* New() const final {
    return CreateMaybeMessage<TestExtensionOrderings1>(NULL);
  }

  TestExtensionOrderings1* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestExtensionOrderings1>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestExtensionOrderings1& from);
  void MergeFrom(const TestExtensionOrderings1& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TestExtensionOrderings1* other);
  protected:
  explicit TestExtensionOrderings1(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional string my_string = 1;
  bool has_my_string() const;
  void clear_my_string();
  static const int kMyStringFieldNumber = 1;
  const ::std::string& my_string() const;
  void set_my_string(const ::std::string& value);
  #if LANG_CXX11
  void set_my_string(::std::string&& value);
  #endif
  void set_my_string(const char* value);
  void set_my_string(const char* value, size_t size);
  ::std::string* mutable_my_string();
  ::std::string* release_my_string();
  void set_allocated_my_string(::std::string* my_string);
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  ::std::string* unsafe_arena_release_my_string();
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  void unsafe_arena_set_allocated_my_string(
      ::std::string* my_string);

  static const int kTestExtOrderings1FieldNumber = 13;
  static ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestFieldOrderings,
      ::google::protobuf::internal::MessageTypeTraits< ::protobuf_unittest::TestExtensionOrderings1 >, 11, false >
    test_ext_orderings1;
  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestExtensionOrderings1)
 private:
  void set_has_my_string();
  void clear_has_my_string();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr my_string_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class TestExtensionOrderings2_TestExtensionOrderings3 : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.TestExtensionOrderings2.TestExtensionOrderings3) */ {
 public:
  TestExtensionOrderings2_TestExtensionOrderings3();
  virtual ~TestExtensionOrderings2_TestExtensionOrderings3();

  TestExtensionOrderings2_TestExtensionOrderings3(const TestExtensionOrderings2_TestExtensionOrderings3& from);

  inline TestExtensionOrderings2_TestExtensionOrderings3& operator=(const TestExtensionOrderings2_TestExtensionOrderings3& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TestExtensionOrderings2_TestExtensionOrderings3(TestExtensionOrderings2_TestExtensionOrderings3&& from) noexcept
    : TestExtensionOrderings2_TestExtensionOrderings3() {
    *this = ::std::move(from);
  }

  inline TestExtensionOrderings2_TestExtensionOrderings3& operator=(TestExtensionOrderings2_TestExtensionOrderings3&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const TestExtensionOrderings2_TestExtensionOrderings3& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TestExtensionOrderings2_TestExtensionOrderings3* internal_default_instance() {
    return reinterpret_cast<const TestExtensionOrderings2_TestExtensionOrderings3*>(
               &_TestExtensionOrderings2_TestExtensionOrderings3_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    44;

  void UnsafeArenaSwap(TestExtensionOrderings2_TestExtensionOrderings3* other);
  void Swap(TestExtensionOrderings2_TestExtensionOrderings3* other);
  friend void swap(TestExtensionOrderings2_TestExtensionOrderings3& a, TestExtensionOrderings2_TestExtensionOrderings3& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline TestExtensionOrderings2_TestExtensionOrderings3* New() const final {
    return CreateMaybeMessage<TestExtensionOrderings2_TestExtensionOrderings3>(NULL);
  }

  TestExtensionOrderings2_TestExtensionOrderings3* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestExtensionOrderings2_TestExtensionOrderings3>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestExtensionOrderings2_TestExtensionOrderings3& from);
  void MergeFrom(const TestExtensionOrderings2_TestExtensionOrderings3& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TestExtensionOrderings2_TestExtensionOrderings3* other);
  protected:
  explicit TestExtensionOrderings2_TestExtensionOrderings3(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional string my_string = 1;
  bool has_my_string() const;
  void clear_my_string();
  static const int kMyStringFieldNumber = 1;
  const ::std::string& my_string() const;
  void set_my_string(const ::std::string& value);
  #if LANG_CXX11
  void set_my_string(::std::string&& value);
  #endif
  void set_my_string(const char* value);
  void set_my_string(const char* value, size_t size);
  ::std::string* mutable_my_string();
  ::std::string* release_my_string();
  void set_allocated_my_string(::std::string* my_string);
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  ::std::string* unsafe_arena_release_my_string();
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  void unsafe_arena_set_allocated_my_string(
      ::std::string* my_string);

  static const int kTestExtOrderings3FieldNumber = 14;
  static ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestFieldOrderings,
      ::google::protobuf::internal::MessageTypeTraits< ::protobuf_unittest::TestExtensionOrderings2_TestExtensionOrderings3 >, 11, false >
    test_ext_orderings3;
  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestExtensionOrderings2.TestExtensionOrderings3)
 private:
  void set_has_my_string();
  void clear_has_my_string();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr my_string_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class TestExtensionOrderings2 : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.TestExtensionOrderings2) */ {
 public:
  TestExtensionOrderings2();
  virtual ~TestExtensionOrderings2();

  TestExtensionOrderings2(const TestExtensionOrderings2& from);

  inline TestExtensionOrderings2& operator=(const TestExtensionOrderings2& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TestExtensionOrderings2(TestExtensionOrderings2&& from) noexcept
    : TestExtensionOrderings2() {
    *this = ::std::move(from);
  }

  inline TestExtensionOrderings2& operator=(TestExtensionOrderings2&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const TestExtensionOrderings2& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TestExtensionOrderings2* internal_default_instance() {
    return reinterpret_cast<const TestExtensionOrderings2*>(
               &_TestExtensionOrderings2_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    45;

  void UnsafeArenaSwap(TestExtensionOrderings2* other);
  void Swap(TestExtensionOrderings2* other);
  friend void swap(TestExtensionOrderings2& a, TestExtensionOrderings2& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline TestExtensionOrderings2* New() const final {
    return CreateMaybeMessage<TestExtensionOrderings2>(NULL);
  }

  TestExtensionOrderings2* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestExtensionOrderings2>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestExtensionOrderings2& from);
  void MergeFrom(const TestExtensionOrderings2& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TestExtensionOrderings2* other);
  protected:
  explicit TestExtensionOrderings2(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef TestExtensionOrderings2_TestExtensionOrderings3 TestExtensionOrderings3;

  // accessors -------------------------------------------------------

  // optional string my_string = 1;
  bool has_my_string() const;
  void clear_my_string();
  static const int kMyStringFieldNumber = 1;
  const ::std::string& my_string() const;
  void set_my_string(const ::std::string& value);
  #if LANG_CXX11
  void set_my_string(::std::string&& value);
  #endif
  void set_my_string(const char* value);
  void set_my_string(const char* value, size_t size);
  ::std::string* mutable_my_string();
  ::std::string* release_my_string();
  void set_allocated_my_string(::std::string* my_string);
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  ::std::string* unsafe_arena_release_my_string();
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  void unsafe_arena_set_allocated_my_string(
      ::std::string* my_string);

  static const int kTestExtOrderings2FieldNumber = 12;
  static ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestFieldOrderings,
      ::google::protobuf::internal::MessageTypeTraits< ::protobuf_unittest::TestExtensionOrderings2 >, 11, false >
    test_ext_orderings2;
  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestExtensionOrderings2)
 private:
  void set_has_my_string();
  void clear_has_my_string();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr my_string_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class TestExtremeDefaultValues : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.TestExtremeDefaultValues) */ {
 public:
  TestExtremeDefaultValues();
  virtual ~TestExtremeDefaultValues();

  TestExtremeDefaultValues(const TestExtremeDefaultValues& from);

  inline TestExtremeDefaultValues& operator=(const TestExtremeDefaultValues& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TestExtremeDefaultValues(TestExtremeDefaultValues&& from) noexcept
    : TestExtremeDefaultValues() {
    *this = ::std::move(from);
  }

  inline TestExtremeDefaultValues& operator=(TestExtremeDefaultValues&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const TestExtremeDefaultValues& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TestExtremeDefaultValues* internal_default_instance() {
    return reinterpret_cast<const TestExtremeDefaultValues*>(
               &_TestExtremeDefaultValues_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    46;

  void UnsafeArenaSwap(TestExtremeDefaultValues* other);
  void Swap(TestExtremeDefaultValues* other);
  friend void swap(TestExtremeDefaultValues& a, TestExtremeDefaultValues& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline TestExtremeDefaultValues* New() const final {
    return CreateMaybeMessage<TestExtremeDefaultValues>(NULL);
  }

  TestExtremeDefaultValues* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestExtremeDefaultValues>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestExtremeDefaultValues& from);
  void MergeFrom(const TestExtremeDefaultValues& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TestExtremeDefaultValues* other);
  protected:
  explicit TestExtremeDefaultValues(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional bytes escaped_bytes = 1 [default = "\000\001\007\010\014\n\r\t\013\\\'\"\376"];
  bool has_escaped_bytes() const;
  void clear_escaped_bytes();
  static const int kEscapedBytesFieldNumber = 1;
  const ::std::string& escaped_bytes() const;
  void set_escaped_bytes(const ::std::string& value);
  #if LANG_CXX11
  void set_escaped_bytes(::std::string&& value);
  #endif
  void set_escaped_bytes(const char* value);
  void set_escaped_bytes(const void* value, size_t size);
  ::std::string* mutable_escaped_bytes();
  ::std::string* release_escaped_bytes();
  void set_allocated_escaped_bytes(::std::string* escaped_bytes);
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  ::std::string* unsafe_arena_release_escaped_bytes();
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  void unsafe_arena_set_allocated_escaped_bytes(
      ::std::string* escaped_bytes);

  // optional string utf8_string = 6 [default = "\341\210\264"];
  bool has_utf8_string() const;
  void clear_utf8_string();
  static const int kUtf8StringFieldNumber = 6;
  const ::std::string& utf8_string() const;
  void set_utf8_string(const ::std::string& value);
  #if LANG_CXX11
  void set_utf8_string(::std::string&& value);
  #endif
  void set_utf8_string(const char* value);
  void set_utf8_string(const char* value, size_t size);
  ::std::string* mutable_utf8_string();
  ::std::string* release_utf8_string();
  void set_allocated_utf8_string(::std::string* utf8_string);
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  ::std::string* unsafe_arena_release_utf8_string();
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  void unsafe_arena_set_allocated_utf8_string(
      ::std::string* utf8_string);

  // optional string cpp_trigraph = 20 [default = "? ? ?? ?? ??? ??/ ??-"];
  bool has_cpp_trigraph() const;
  void clear_cpp_trigraph();
  static const int kCppTrigraphFieldNumber = 20;
  const ::std::string& cpp_trigraph() const;
  void set_cpp_trigraph(const ::std::string& value);
  #if LANG_CXX11
  void set_cpp_trigraph(::std::string&& value);
  #endif
  void set_cpp_trigraph(const char* value);
  void set_cpp_trigraph(const char* value, size_t size);
  ::std::string* mutable_cpp_trigraph();
  ::std::string* release_cpp_trigraph();
  void set_allocated_cpp_trigraph(::std::string* cpp_trigraph);
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  ::std::string* unsafe_arena_release_cpp_trigraph();
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  void unsafe_arena_set_allocated_cpp_trigraph(
      ::std::string* cpp_trigraph);

  // optional string string_with_zero = 23 [default = "hel\000lo"];
  bool has_string_with_zero() const;
  void clear_string_with_zero();
  static const int kStringWithZeroFieldNumber = 23;
  const ::std::string& string_with_zero() const;
  void set_string_with_zero(const ::std::string& value);
  #if LANG_CXX11
  void set_string_with_zero(::std::string&& value);
  #endif
  void set_string_with_zero(const char* value);
  void set_string_with_zero(const char* value, size_t size);
  ::std::string* mutable_string_with_zero();
  ::std::string* release_string_with_zero();
  void set_allocated_string_with_zero(::std::string* string_with_zero);
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  ::std::string* unsafe_arena_release_string_with_zero();
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  void unsafe_arena_set_allocated_string_with_zero(
      ::std::string* string_with_zero);

  // optional bytes bytes_with_zero = 24 [default = "wor\000ld"];
  bool has_bytes_with_zero() const;
  void clear_bytes_with_zero();
  static const int kBytesWithZeroFieldNumber = 24;
  const ::std::string& bytes_with_zero() const;
  void set_bytes_with_zero(const ::std::string& value);
  #if LANG_CXX11
  void set_bytes_with_zero(::std::string&& value);
  #endif
  void set_bytes_with_zero(const char* value);
  void set_bytes_with_zero(const void* value, size_t size);
  ::std::string* mutable_bytes_with_zero();
  ::std::string* release_bytes_with_zero();
  void set_allocated_bytes_with_zero(::std::string* bytes_with_zero);
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  ::std::string* unsafe_arena_release_bytes_with_zero();
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  void unsafe_arena_set_allocated_bytes_with_zero(
      ::std::string* bytes_with_zero);

  // optional string string_piece_with_zero = 25 [default = "ab\000c", ctype = STRING_PIECE];
  bool has_string_piece_with_zero() const;
  void clear_string_piece_with_zero();
  static const int kStringPieceWithZeroFieldNumber = 25;
 private:
  // Hidden due to unknown ctype option.
  const ::std::string& string_piece_with_zero() const;
  void set_string_piece_with_zero(const ::std::string& value);
  #if LANG_CXX11
  void set_string_piece_with_zero(::std::string&& value);
  #endif
  void set_string_piece_with_zero(const char* value);
  void set_string_piece_with_zero(const char* value, size_t size);
  ::std::string* mutable_string_piece_with_zero();
  ::std::string* release_string_piece_with_zero();
  void set_allocated_string_piece_with_zero(::std::string* string_piece_with_zero);
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  ::std::string* unsafe_arena_release_string_piece_with_zero();
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  void unsafe_arena_set_allocated_string_piece_with_zero(
      ::std::string* string_piece_with_zero);
 public:

  // optional string cord_with_zero = 26 [default = "12\0003", ctype = CORD];
  bool has_cord_with_zero() const;
  void clear_cord_with_zero();
  static const int kCordWithZeroFieldNumber = 26;
 private:
  // Hidden due to unknown ctype option.
  const ::std::string& cord_with_zero() const;
  void set_cord_with_zero(const ::std::string& value);
  #if LANG_CXX11
  void set_cord_with_zero(::std::string&& value);
  #endif
  void set_cord_with_zero(const char* value);
  void set_cord_with_zero(const char* value, size_t size);
  ::std::string* mutable_cord_with_zero();
  ::std::string* release_cord_with_zero();
  void set_allocated_cord_with_zero(::std::string* cord_with_zero);
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  ::std::string* unsafe_arena_release_cord_with_zero();
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  void unsafe_arena_set_allocated_cord_with_zero(
      ::std::string* cord_with_zero);
 public:

  // optional string replacement_string = 27 [default = "${unknown}"];
  bool has_replacement_string() const;
  void clear_replacement_string();
  static const int kReplacementStringFieldNumber = 27;
  const ::std::string& replacement_string() const;
  void set_replacement_string(const ::std::string& value);
  #if LANG_CXX11
  void set_replacement_string(::std::string&& value);
  #endif
  void set_replacement_string(const char* value);
  void set_replacement_string(const char* value, size_t size);
  ::std::string* mutable_replacement_string();
  ::std::string* release_replacement_string();
  void set_allocated_replacement_string(::std::string* replacement_string);
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  ::std::string* unsafe_arena_release_replacement_string();
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  void unsafe_arena_set_allocated_replacement_string(
      ::std::string* replacement_string);

  // optional float zero_float = 7 [default = 0];
  bool has_zero_float() const;
  void clear_zero_float();
  static const int kZeroFloatFieldNumber = 7;
  float zero_float() const;
  void set_zero_float(float value);

  // optional uint64 large_uint64 = 3 [default = 18446744073709551615];
  bool has_large_uint64() const;
  void clear_large_uint64();
  static const int kLargeUint64FieldNumber = 3;
  ::google::protobuf::uint64 large_uint64() const;
  void set_large_uint64(::google::protobuf::uint64 value);

  // optional uint32 large_uint32 = 2 [default = 4294967295];
  bool has_large_uint32() const;
  void clear_large_uint32();
  static const int kLargeUint32FieldNumber = 2;
  ::google::protobuf::uint32 large_uint32() const;
  void set_large_uint32(::google::protobuf::uint32 value);

  // optional int32 small_int32 = 4 [default = -2147483647];
  bool has_small_int32() const;
  void clear_small_int32();
  static const int kSmallInt32FieldNumber = 4;
  ::google::protobuf::int32 small_int32() const;
  void set_small_int32(::google::protobuf::int32 value);

  // optional int64 small_int64 = 5 [default = -9223372036854775807];
  bool has_small_int64() const;
  void clear_small_int64();
  static const int kSmallInt64FieldNumber = 5;
  ::google::protobuf::int64 small_int64() const;
  void set_small_int64(::google::protobuf::int64 value);

  // optional float one_float = 8 [default = 1];
  bool has_one_float() const;
  void clear_one_float();
  static const int kOneFloatFieldNumber = 8;
  float one_float() const;
  void set_one_float(float value);

  // optional float small_float = 9 [default = 1.5];
  bool has_small_float() const;
  void clear_small_float();
  static const int kSmallFloatFieldNumber = 9;
  float small_float() const;
  void set_small_float(float value);

  // optional float negative_one_float = 10 [default = -1];
  bool has_negative_one_float() const;
  void clear_negative_one_float();
  static const int kNegativeOneFloatFieldNumber = 10;
  float negative_one_float() const;
  void set_negative_one_float(float value);

  // optional float negative_float = 11 [default = -1.5];
  bool has_negative_float() const;
  void clear_negative_float();
  static const int kNegativeFloatFieldNumber = 11;
  float negative_float() const;
  void set_negative_float(float value);

  // optional float large_float = 12 [default = 2e+08];
  bool has_large_float() const;
  void clear_large_float();
  static const int kLargeFloatFieldNumber = 12;
  float large_float() const;
  void set_large_float(float value);

  // optional float small_negative_float = 13 [default = -8e-28];
  bool has_small_negative_float() const;
  void clear_small_negative_float();
  static const int kSmallNegativeFloatFieldNumber = 13;
  float small_negative_float() const;
  void set_small_negative_float(float value);

  // optional double inf_double = 14 [default = inf];
  bool has_inf_double() const;
  void clear_inf_double();
  static const int kInfDoubleFieldNumber = 14;
  double inf_double() const;
  void set_inf_double(double value);

  // optional double neg_inf_double = 15 [default = -inf];
  bool has_neg_inf_double() const;
  void clear_neg_inf_double();
  static const int kNegInfDoubleFieldNumber = 15;
  double neg_inf_double() const;
  void set_neg_inf_double(double value);

  // optional double nan_double = 16 [default = nan];
  bool has_nan_double() const;
  void clear_nan_double();
  static const int kNanDoubleFieldNumber = 16;
  double nan_double() const;
  void set_nan_double(double value);

  // optional float inf_float = 17 [default = inf];
  bool has_inf_float() const;
  void clear_inf_float();
  static const int kInfFloatFieldNumber = 17;
  float inf_float() const;
  void set_inf_float(float value);

  // optional float neg_inf_float = 18 [default = -inf];
  bool has_neg_inf_float() const;
  void clear_neg_inf_float();
  static const int kNegInfFloatFieldNumber = 18;
  float neg_inf_float() const;
  void set_neg_inf_float(float value);

  // optional float nan_float = 19 [default = nan];
  bool has_nan_float() const;
  void clear_nan_float();
  static const int kNanFloatFieldNumber = 19;
  float nan_float() const;
  void set_nan_float(float value);

  // optional int32 really_small_int32 = 21 [default = -2147483648];
  bool has_really_small_int32() const;
  void clear_really_small_int32();
  static const int kReallySmallInt32FieldNumber = 21;
  ::google::protobuf::int32 really_small_int32() const;
  void set_really_small_int32(::google::protobuf::int32 value);

  // optional int64 really_small_int64 = 22 [default = -9223372036854775808];
  bool has_really_small_int64() const;
  void clear_really_small_int64();
  static const int kReallySmallInt64FieldNumber = 22;
  ::google::protobuf::int64 really_small_int64() const;
  void set_really_small_int64(::google::protobuf::int64 value);

  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestExtremeDefaultValues)
 private:
  void set_has_escaped_bytes();
  void clear_has_escaped_bytes();
  void set_has_large_uint32();
  void clear_has_large_uint32();
  void set_has_large_uint64();
  void clear_has_large_uint64();
  void set_has_small_int32();
  void clear_has_small_int32();
  void set_has_small_int64();
  void clear_has_small_int64();
  void set_has_really_small_int32();
  void clear_has_really_small_int32();
  void set_has_really_small_int64();
  void clear_has_really_small_int64();
  void set_has_utf8_string();
  void clear_has_utf8_string();
  void set_has_zero_float();
  void clear_has_zero_float();
  void set_has_one_float();
  void clear_has_one_float();
  void set_has_small_float();
  void clear_has_small_float();
  void set_has_negative_one_float();
  void clear_has_negative_one_float();
  void set_has_negative_float();
  void clear_has_negative_float();
  void set_has_large_float();
  void clear_has_large_float();
  void set_has_small_negative_float();
  void clear_has_small_negative_float();
  void set_has_inf_double();
  void clear_has_inf_double();
  void set_has_neg_inf_double();
  void clear_has_neg_inf_double();
  void set_has_nan_double();
  void clear_has_nan_double();
  void set_has_inf_float();
  void clear_has_inf_float();
  void set_has_neg_inf_float();
  void clear_has_neg_inf_float();
  void set_has_nan_float();
  void clear_has_nan_float();
  void set_has_cpp_trigraph();
  void clear_has_cpp_trigraph();
  void set_has_string_with_zero();
  void clear_has_string_with_zero();
  void set_has_bytes_with_zero();
  void clear_has_bytes_with_zero();
  void set_has_string_piece_with_zero();
  void clear_has_string_piece_with_zero();
  void set_has_cord_with_zero();
  void clear_has_cord_with_zero();
  void set_has_replacement_string();
  void clear_has_replacement_string();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  public:
  static ::google::protobuf::internal::ExplicitlyConstructed< ::std::string> _i_give_permission_to_break_this_code_default_escaped_bytes_;
  private:
  ::google::protobuf::internal::ArenaStringPtr escaped_bytes_;
  public:
  static ::google::protobuf::internal::ExplicitlyConstructed< ::std::string> _i_give_permission_to_break_this_code_default_utf8_string_;
  private:
  ::google::protobuf::internal::ArenaStringPtr utf8_string_;
  public:
  static ::google::protobuf::internal::ExplicitlyConstructed< ::std::string> _i_give_permission_to_break_this_code_default_cpp_trigraph_;
  private:
  ::google::protobuf::internal::ArenaStringPtr cpp_trigraph_;
  public:
  static ::google::protobuf::internal::ExplicitlyConstructed< ::std::string> _i_give_permission_to_break_this_code_default_string_with_zero_;
  private:
  ::google::protobuf::internal::ArenaStringPtr string_with_zero_;
  public:
  static ::google::protobuf::internal::ExplicitlyConstructed< ::std::string> _i_give_permission_to_break_this_code_default_bytes_with_zero_;
  private:
  ::google::protobuf::internal::ArenaStringPtr bytes_with_zero_;
  public:
  static ::google::protobuf::internal::ExplicitlyConstructed< ::std::string> _i_give_permission_to_break_this_code_default_string_piece_with_zero_;
  private:
  ::google::protobuf::internal::ArenaStringPtr string_piece_with_zero_;
  public:
  static ::google::protobuf::internal::ExplicitlyConstructed< ::std::string> _i_give_permission_to_break_this_code_default_cord_with_zero_;
  private:
  ::google::protobuf::internal::ArenaStringPtr cord_with_zero_;
  public:
  static ::google::protobuf::internal::ExplicitlyConstructed< ::std::string> _i_give_permission_to_break_this_code_default_replacement_string_;
  private:
  ::google::protobuf::internal::ArenaStringPtr replacement_string_;
  float zero_float_;
  ::google::protobuf::uint64 large_uint64_;
  ::google::protobuf::uint32 large_uint32_;
  ::google::protobuf::int32 small_int32_;
  ::google::protobuf::int64 small_int64_;
  float one_float_;
  float small_float_;
  float negative_one_float_;
  float negative_float_;
  float large_float_;
  float small_negative_float_;
  double inf_double_;
  double neg_inf_double_;
  double nan_double_;
  float inf_float_;
  float neg_inf_float_;
  float nan_float_;
  ::google::protobuf::int32 really_small_int32_;
  ::google::protobuf::int64 really_small_int64_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class SparseEnumMessage : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.SparseEnumMessage) */ {
 public:
  SparseEnumMessage();
  virtual ~SparseEnumMessage();

  SparseEnumMessage(const SparseEnumMessage& from);

  inline SparseEnumMessage& operator=(const SparseEnumMessage& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  SparseEnumMessage(SparseEnumMessage&& from) noexcept
    : SparseEnumMessage() {
    *this = ::std::move(from);
  }

  inline SparseEnumMessage& operator=(SparseEnumMessage&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const SparseEnumMessage& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const SparseEnumMessage* internal_default_instance() {
    return reinterpret_cast<const SparseEnumMessage*>(
               &_SparseEnumMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    47;

  void UnsafeArenaSwap(SparseEnumMessage* other);
  void Swap(SparseEnumMessage* other);
  friend void swap(SparseEnumMessage& a, SparseEnumMessage& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline SparseEnumMessage* New() const final {
    return CreateMaybeMessage<SparseEnumMessage>(NULL);
  }

  SparseEnumMessage* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<SparseEnumMessage>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const SparseEnumMessage& from);
  void MergeFrom(const SparseEnumMessage& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SparseEnumMessage* other);
  protected:
  explicit SparseEnumMessage(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .protobuf_unittest.TestSparseEnum sparse_enum = 1;
  bool has_sparse_enum() const;
  void clear_sparse_enum();
  static const int kSparseEnumFieldNumber = 1;
  ::protobuf_unittest::TestSparseEnum sparse_enum() const;
  void set_sparse_enum(::protobuf_unittest::TestSparseEnum value);

  // @@protoc_insertion_point(class_scope:protobuf_unittest.SparseEnumMessage)
 private:
  void set_has_sparse_enum();
  void clear_has_sparse_enum();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  int sparse_enum_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class OneString : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.OneString) */ {
 public:
  OneString();
  virtual ~OneString();

  OneString(const OneString& from);

  inline OneString& operator=(const OneString& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  OneString(OneString&& from) noexcept
    : OneString() {
    *this = ::std::move(from);
  }

  inline OneString& operator=(OneString&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const OneString& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const OneString* internal_default_instance() {
    return reinterpret_cast<const OneString*>(
               &_OneString_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    48;

  void UnsafeArenaSwap(OneString* other);
  void Swap(OneString* other);
  friend void swap(OneString& a, OneString& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline OneString* New() const final {
    return CreateMaybeMessage<OneString>(NULL);
  }

  OneString* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<OneString>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const OneString& from);
  void MergeFrom(const OneString& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(OneString* other);
  protected:
  explicit OneString(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional string data = 1;
  bool has_data() const;
  void clear_data();
  static const int kDataFieldNumber = 1;
  const ::std::string& data() const;
  void set_data(const ::std::string& value);
  #if LANG_CXX11
  void set_data(::std::string&& value);
  #endif
  void set_data(const char* value);
  void set_data(const char* value, size_t size);
  ::std::string* mutable_data();
  ::std::string* release_data();
  void set_allocated_data(::std::string* data);
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  ::std::string* unsafe_arena_release_data();
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  void unsafe_arena_set_allocated_data(
      ::std::string* data);

  // @@protoc_insertion_point(class_scope:protobuf_unittest.OneString)
 private:
  void set_has_data();
  void clear_has_data();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr data_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class MoreString : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.MoreString) */ {
 public:
  MoreString();
  virtual ~MoreString();

  MoreString(const MoreString& from);

  inline MoreString& operator=(const MoreString& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  MoreString(MoreString&& from) noexcept
    : MoreString() {
    *this = ::std::move(from);
  }

  inline MoreString& operator=(MoreString&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const MoreString& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const MoreString* internal_default_instance() {
    return reinterpret_cast<const MoreString*>(
               &_MoreString_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    49;

  void UnsafeArenaSwap(MoreString* other);
  void Swap(MoreString* other);
  friend void swap(MoreString& a, MoreString& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline MoreString* New() const final {
    return CreateMaybeMessage<MoreString>(NULL);
  }

  MoreString* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<MoreString>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const MoreString& from);
  void MergeFrom(const MoreString& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(MoreString* other);
  protected:
  explicit MoreString(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated string data = 1;
  int data_size() const;
  void clear_data();
  static const int kDataFieldNumber = 1;
  const ::std::string& data(int index) const;
  ::std::string* mutable_data(int index);
  void set_data(int index, const ::std::string& value);
  #if LANG_CXX11
  void set_data(int index, ::std::string&& value);
  #endif
  void set_data(int index, const char* value);
  void set_data(int index, const char* value, size_t size);
  ::std::string* add_data();
  void add_data(const ::std::string& value);
  #if LANG_CXX11
  void add_data(::std::string&& value);
  #endif
  void add_data(const char* value);
  void add_data(const char* value, size_t size);
  const ::google::protobuf::RepeatedPtrField< ::std::string>& data() const;
  ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_data();

  // @@protoc_insertion_point(class_scope:protobuf_unittest.MoreString)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::RepeatedPtrField< ::std::string> data_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class OneBytes : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.OneBytes) */ {
 public:
  OneBytes();
  virtual ~OneBytes();

  OneBytes(const OneBytes& from);

  inline OneBytes& operator=(const OneBytes& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  OneBytes(OneBytes&& from) noexcept
    : OneBytes() {
    *this = ::std::move(from);
  }

  inline OneBytes& operator=(OneBytes&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const OneBytes& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const OneBytes* internal_default_instance() {
    return reinterpret_cast<const OneBytes*>(
               &_OneBytes_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    50;

  void UnsafeArenaSwap(OneBytes* other);
  void Swap(OneBytes* other);
  friend void swap(OneBytes& a, OneBytes& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline OneBytes* New() const final {
    return CreateMaybeMessage<OneBytes>(NULL);
  }

  OneBytes* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<OneBytes>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const OneBytes& from);
  void MergeFrom(const OneBytes& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(OneBytes* other);
  protected:
  explicit OneBytes(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional bytes data = 1;
  bool has_data() const;
  void clear_data();
  static const int kDataFieldNumber = 1;
  const ::std::string& data() const;
  void set_data(const ::std::string& value);
  #if LANG_CXX11
  void set_data(::std::string&& value);
  #endif
  void set_data(const char* value);
  void set_data(const void* value, size_t size);
  ::std::string* mutable_data();
  ::std::string* release_data();
  void set_allocated_data(::std::string* data);
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  ::std::string* unsafe_arena_release_data();
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  void unsafe_arena_set_allocated_data(
      ::std::string* data);

  // @@protoc_insertion_point(class_scope:protobuf_unittest.OneBytes)
 private:
  void set_has_data();
  void clear_has_data();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr data_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class MoreBytes : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.MoreBytes) */ {
 public:
  MoreBytes();
  virtual ~MoreBytes();

  MoreBytes(const MoreBytes& from);

  inline MoreBytes& operator=(const MoreBytes& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  MoreBytes(MoreBytes&& from) noexcept
    : MoreBytes() {
    *this = ::std::move(from);
  }

  inline MoreBytes& operator=(MoreBytes&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const MoreBytes& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const MoreBytes* internal_default_instance() {
    return reinterpret_cast<const MoreBytes*>(
               &_MoreBytes_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    51;

  void UnsafeArenaSwap(MoreBytes* other);
  void Swap(MoreBytes* other);
  friend void swap(MoreBytes& a, MoreBytes& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline MoreBytes* New() const final {
    return CreateMaybeMessage<MoreBytes>(NULL);
  }

  MoreBytes* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<MoreBytes>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const MoreBytes& from);
  void MergeFrom(const MoreBytes& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(MoreBytes* other);
  protected:
  explicit MoreBytes(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated bytes data = 1;
  int data_size() const;
  void clear_data();
  static const int kDataFieldNumber = 1;
  const ::std::string& data(int index) const;
  ::std::string* mutable_data(int index);
  void set_data(int index, const ::std::string& value);
  #if LANG_CXX11
  void set_data(int index, ::std::string&& value);
  #endif
  void set_data(int index, const char* value);
  void set_data(int index, const void* value, size_t size);
  ::std::string* add_data();
  void add_data(const ::std::string& value);
  #if LANG_CXX11
  void add_data(::std::string&& value);
  #endif
  void add_data(const char* value);
  void add_data(const void* value, size_t size);
  const ::google::protobuf::RepeatedPtrField< ::std::string>& data() const;
  ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_data();

  // @@protoc_insertion_point(class_scope:protobuf_unittest.MoreBytes)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::RepeatedPtrField< ::std::string> data_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class Int32Message : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.Int32Message) */ {
 public:
  Int32Message();
  virtual ~Int32Message();

  Int32Message(const Int32Message& from);

  inline Int32Message& operator=(const Int32Message& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  Int32Message(Int32Message&& from) noexcept
    : Int32Message() {
    *this = ::std::move(from);
  }

  inline Int32Message& operator=(Int32Message&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const Int32Message& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const Int32Message* internal_default_instance() {
    return reinterpret_cast<const Int32Message*>(
               &_Int32Message_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    52;

  void UnsafeArenaSwap(Int32Message* other);
  void Swap(Int32Message* other);
  friend void swap(Int32Message& a, Int32Message& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline Int32Message* New() const final {
    return CreateMaybeMessage<Int32Message>(NULL);
  }

  Int32Message* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<Int32Message>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const Int32Message& from);
  void MergeFrom(const Int32Message& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Int32Message* other);
  protected:
  explicit Int32Message(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional int32 data = 1;
  bool has_data() const;
  void clear_data();
  static const int kDataFieldNumber = 1;
  ::google::protobuf::int32 data() const;
  void set_data(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:protobuf_unittest.Int32Message)
 private:
  void set_has_data();
  void clear_has_data();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::int32 data_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class Uint32Message : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.Uint32Message) */ {
 public:
  Uint32Message();
  virtual ~Uint32Message();

  Uint32Message(const Uint32Message& from);

  inline Uint32Message& operator=(const Uint32Message& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  Uint32Message(Uint32Message&& from) noexcept
    : Uint32Message() {
    *this = ::std::move(from);
  }

  inline Uint32Message& operator=(Uint32Message&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const Uint32Message& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const Uint32Message* internal_default_instance() {
    return reinterpret_cast<const Uint32Message*>(
               &_Uint32Message_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    53;

  void UnsafeArenaSwap(Uint32Message* other);
  void Swap(Uint32Message* other);
  friend void swap(Uint32Message& a, Uint32Message& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline Uint32Message* New() const final {
    return CreateMaybeMessage<Uint32Message>(NULL);
  }

  Uint32Message* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<Uint32Message>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const Uint32Message& from);
  void MergeFrom(const Uint32Message& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Uint32Message* other);
  protected:
  explicit Uint32Message(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional uint32 data = 1;
  bool has_data() const;
  void clear_data();
  static const int kDataFieldNumber = 1;
  ::google::protobuf::uint32 data() const;
  void set_data(::google::protobuf::uint32 value);

  // @@protoc_insertion_point(class_scope:protobuf_unittest.Uint32Message)
 private:
  void set_has_data();
  void clear_has_data();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::uint32 data_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class Int64Message : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.Int64Message) */ {
 public:
  Int64Message();
  virtual ~Int64Message();

  Int64Message(const Int64Message& from);

  inline Int64Message& operator=(const Int64Message& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  Int64Message(Int64Message&& from) noexcept
    : Int64Message() {
    *this = ::std::move(from);
  }

  inline Int64Message& operator=(Int64Message&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const Int64Message& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const Int64Message* internal_default_instance() {
    return reinterpret_cast<const Int64Message*>(
               &_Int64Message_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    54;

  void UnsafeArenaSwap(Int64Message* other);
  void Swap(Int64Message* other);
  friend void swap(Int64Message& a, Int64Message& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline Int64Message* New() const final {
    return CreateMaybeMessage<Int64Message>(NULL);
  }

  Int64Message* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<Int64Message>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const Int64Message& from);
  void MergeFrom(const Int64Message& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Int64Message* other);
  protected:
  explicit Int64Message(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional int64 data = 1;
  bool has_data() const;
  void clear_data();
  static const int kDataFieldNumber = 1;
  ::google::protobuf::int64 data() const;
  void set_data(::google::protobuf::int64 value);

  // @@protoc_insertion_point(class_scope:protobuf_unittest.Int64Message)
 private:
  void set_has_data();
  void clear_has_data();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::int64 data_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class Uint64Message : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.Uint64Message) */ {
 public:
  Uint64Message();
  virtual ~Uint64Message();

  Uint64Message(const Uint64Message& from);

  inline Uint64Message& operator=(const Uint64Message& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  Uint64Message(Uint64Message&& from) noexcept
    : Uint64Message() {
    *this = ::std::move(from);
  }

  inline Uint64Message& operator=(Uint64Message&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const Uint64Message& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const Uint64Message* internal_default_instance() {
    return reinterpret_cast<const Uint64Message*>(
               &_Uint64Message_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    55;

  void UnsafeArenaSwap(Uint64Message* other);
  void Swap(Uint64Message* other);
  friend void swap(Uint64Message& a, Uint64Message& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline Uint64Message* New() const final {
    return CreateMaybeMessage<Uint64Message>(NULL);
  }

  Uint64Message* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<Uint64Message>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const Uint64Message& from);
  void MergeFrom(const Uint64Message& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Uint64Message* other);
  protected:
  explicit Uint64Message(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional uint64 data = 1;
  bool has_data() const;
  void clear_data();
  static const int kDataFieldNumber = 1;
  ::google::protobuf::uint64 data() const;
  void set_data(::google::protobuf::uint64 value);

  // @@protoc_insertion_point(class_scope:protobuf_unittest.Uint64Message)
 private:
  void set_has_data();
  void clear_has_data();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::uint64 data_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class BoolMessage : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.BoolMessage) */ {
 public:
  BoolMessage();
  virtual ~BoolMessage();

  BoolMessage(const BoolMessage& from);

  inline BoolMessage& operator=(const BoolMessage& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  BoolMessage(BoolMessage&& from) noexcept
    : BoolMessage() {
    *this = ::std::move(from);
  }

  inline BoolMessage& operator=(BoolMessage&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const BoolMessage& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const BoolMessage* internal_default_instance() {
    return reinterpret_cast<const BoolMessage*>(
               &_BoolMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    56;

  void UnsafeArenaSwap(BoolMessage* other);
  void Swap(BoolMessage* other);
  friend void swap(BoolMessage& a, BoolMessage& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline BoolMessage* New() const final {
    return CreateMaybeMessage<BoolMessage>(NULL);
  }

  BoolMessage* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<BoolMessage>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const BoolMessage& from);
  void MergeFrom(const BoolMessage& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(BoolMessage* other);
  protected:
  explicit BoolMessage(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional bool data = 1;
  bool has_data() const;
  void clear_data();
  static const int kDataFieldNumber = 1;
  bool data() const;
  void set_data(bool value);

  // @@protoc_insertion_point(class_scope:protobuf_unittest.BoolMessage)
 private:
  void set_has_data();
  void clear_has_data();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  bool data_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class TestOneof_FooGroup : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.TestOneof.FooGroup) */ {
 public:
  TestOneof_FooGroup();
  virtual ~TestOneof_FooGroup();

  TestOneof_FooGroup(const TestOneof_FooGroup& from);

  inline TestOneof_FooGroup& operator=(const TestOneof_FooGroup& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TestOneof_FooGroup(TestOneof_FooGroup&& from) noexcept
    : TestOneof_FooGroup() {
    *this = ::std::move(from);
  }

  inline TestOneof_FooGroup& operator=(TestOneof_FooGroup&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const TestOneof_FooGroup& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TestOneof_FooGroup* internal_default_instance() {
    return reinterpret_cast<const TestOneof_FooGroup*>(
               &_TestOneof_FooGroup_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    57;

  void UnsafeArenaSwap(TestOneof_FooGroup* other);
  void Swap(TestOneof_FooGroup* other);
  friend void swap(TestOneof_FooGroup& a, TestOneof_FooGroup& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline TestOneof_FooGroup* New() const final {
    return CreateMaybeMessage<TestOneof_FooGroup>(NULL);
  }

  TestOneof_FooGroup* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestOneof_FooGroup>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestOneof_FooGroup& from);
  void MergeFrom(const TestOneof_FooGroup& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TestOneof_FooGroup* other);
  protected:
  explicit TestOneof_FooGroup(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional string b = 6;
  bool has_b() const;
  void clear_b();
  static const int kBFieldNumber = 6;
  const ::std::string& b() const;
  void set_b(const ::std::string& value);
  #if LANG_CXX11
  void set_b(::std::string&& value);
  #endif
  void set_b(const char* value);
  void set_b(const char* value, size_t size);
  ::std::string* mutable_b();
  ::std::string* release_b();
  void set_allocated_b(::std::string* b);
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  ::std::string* unsafe_arena_release_b();
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  void unsafe_arena_set_allocated_b(
      ::std::string* b);

  // optional int32 a = 5;
  bool has_a() const;
  void clear_a();
  static const int kAFieldNumber = 5;
  ::google::protobuf::int32 a() const;
  void set_a(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestOneof.FooGroup)
 private:
  void set_has_a();
  void clear_has_a();
  void set_has_b();
  void clear_has_b();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr b_;
  ::google::protobuf::int32 a_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class TestOneof : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.TestOneof) */ {
 public:
  TestOneof();
  virtual ~TestOneof();

  TestOneof(const TestOneof& from);

  inline TestOneof& operator=(const TestOneof& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TestOneof(TestOneof&& from) noexcept
    : TestOneof() {
    *this = ::std::move(from);
  }

  inline TestOneof& operator=(TestOneof&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const TestOneof& default_instance();

  enum FooCase {
    kFooInt = 1,
    kFooString = 2,
    kFooMessage = 3,
    kFoogroup = 4,
    FOO_NOT_SET = 0,
  };

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TestOneof* internal_default_instance() {
    return reinterpret_cast<const TestOneof*>(
               &_TestOneof_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    58;

  void UnsafeArenaSwap(TestOneof* other);
  void Swap(TestOneof* other);
  friend void swap(TestOneof& a, TestOneof& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline TestOneof* New() const final {
    return CreateMaybeMessage<TestOneof>(NULL);
  }

  TestOneof* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestOneof>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestOneof& from);
  void MergeFrom(const TestOneof& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TestOneof* other);
  protected:
  explicit TestOneof(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef TestOneof_FooGroup FooGroup;

  // accessors -------------------------------------------------------

  // optional int32 foo_int = 1;
  bool has_foo_int() const;
  void clear_foo_int();
  static const int kFooIntFieldNumber = 1;
  ::google::protobuf::int32 foo_int() const;
  void set_foo_int(::google::protobuf::int32 value);

  // optional string foo_string = 2;
  bool has_foo_string() const;
  void clear_foo_string();
  static const int kFooStringFieldNumber = 2;
  const ::std::string& foo_string() const;
  void set_foo_string(const ::std::string& value);
  #if LANG_CXX11
  void set_foo_string(::std::string&& value);
  #endif
  void set_foo_string(const char* value);
  void set_foo_string(const char* value, size_t size);
  ::std::string* mutable_foo_string();
  ::std::string* release_foo_string();
  void set_allocated_foo_string(::std::string* foo_string);
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  ::std::string* unsafe_arena_release_foo_string();
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  void unsafe_arena_set_allocated_foo_string(
      ::std::string* foo_string);

  // optional .protobuf_unittest.TestAllTypes foo_message = 3;
  bool has_foo_message() const;
  void clear_foo_message();
  static const int kFooMessageFieldNumber = 3;
  private:
  const ::protobuf_unittest::TestAllTypes& _internal_foo_message() const;
  public:
  const ::protobuf_unittest::TestAllTypes& foo_message() const;
  ::protobuf_unittest::TestAllTypes* release_foo_message();
  ::protobuf_unittest::TestAllTypes* mutable_foo_message();
  void set_allocated_foo_message(::protobuf_unittest::TestAllTypes* foo_message);
  void unsafe_arena_set_allocated_foo_message(
      ::protobuf_unittest::TestAllTypes* foo_message);
  ::protobuf_unittest::TestAllTypes* unsafe_arena_release_foo_message();

  // optional group FooGroup = 4 { ... };
  bool has_foogroup() const;
  void clear_foogroup();
  static const int kFoogroupFieldNumber = 4;
  private:
  const ::protobuf_unittest::TestOneof_FooGroup& _internal_foogroup() const;
  public:
  const ::protobuf_unittest::TestOneof_FooGroup& foogroup() const;
  ::protobuf_unittest::TestOneof_FooGroup* release_foogroup();
  ::protobuf_unittest::TestOneof_FooGroup* mutable_foogroup();
  void set_allocated_foogroup(::protobuf_unittest::TestOneof_FooGroup* foogroup);
  void unsafe_arena_set_allocated_foogroup(
      ::protobuf_unittest::TestOneof_FooGroup* foogroup);
  ::protobuf_unittest::TestOneof_FooGroup* unsafe_arena_release_foogroup();

  void clear_foo();
  FooCase foo_case() const;
  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestOneof)
 private:
  void set_has_foo_int();
  void set_has_foo_string();
  void set_has_foo_message();
  void set_has_foogroup();

  inline bool has_foo() const;
  inline void clear_has_foo();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  union FooUnion {
    FooUnion() {}
    ::google::protobuf::int32 foo_int_;
    ::google::protobuf::internal::ArenaStringPtr foo_string_;
    ::protobuf_unittest::TestAllTypes* foo_message_;
    ::protobuf_unittest::TestOneof_FooGroup* foogroup_;
  } foo_;
  ::google::protobuf::uint32 _oneof_case_[1];

  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class TestOneofBackwardsCompatible_FooGroup : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.TestOneofBackwardsCompatible.FooGroup) */ {
 public:
  TestOneofBackwardsCompatible_FooGroup();
  virtual ~TestOneofBackwardsCompatible_FooGroup();

  TestOneofBackwardsCompatible_FooGroup(const TestOneofBackwardsCompatible_FooGroup& from);

  inline TestOneofBackwardsCompatible_FooGroup& operator=(const TestOneofBackwardsCompatible_FooGroup& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TestOneofBackwardsCompatible_FooGroup(TestOneofBackwardsCompatible_FooGroup&& from) noexcept
    : TestOneofBackwardsCompatible_FooGroup() {
    *this = ::std::move(from);
  }

  inline TestOneofBackwardsCompatible_FooGroup& operator=(TestOneofBackwardsCompatible_FooGroup&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const TestOneofBackwardsCompatible_FooGroup& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TestOneofBackwardsCompatible_FooGroup* internal_default_instance() {
    return reinterpret_cast<const TestOneofBackwardsCompatible_FooGroup*>(
               &_TestOneofBackwardsCompatible_FooGroup_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    59;

  void UnsafeArenaSwap(TestOneofBackwardsCompatible_FooGroup* other);
  void Swap(TestOneofBackwardsCompatible_FooGroup* other);
  friend void swap(TestOneofBackwardsCompatible_FooGroup& a, TestOneofBackwardsCompatible_FooGroup& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline TestOneofBackwardsCompatible_FooGroup* New() const final {
    return CreateMaybeMessage<TestOneofBackwardsCompatible_FooGroup>(NULL);
  }

  TestOneofBackwardsCompatible_FooGroup* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestOneofBackwardsCompatible_FooGroup>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestOneofBackwardsCompatible_FooGroup& from);
  void MergeFrom(const TestOneofBackwardsCompatible_FooGroup& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TestOneofBackwardsCompatible_FooGroup* other);
  protected:
  explicit TestOneofBackwardsCompatible_FooGroup(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional string b = 6;
  bool has_b() const;
  void clear_b();
  static const int kBFieldNumber = 6;
  const ::std::string& b() const;
  void set_b(const ::std::string& value);
  #if LANG_CXX11
  void set_b(::std::string&& value);
  #endif
  void set_b(const char* value);
  void set_b(const char* value, size_t size);
  ::std::string* mutable_b();
  ::std::string* release_b();
  void set_allocated_b(::std::string* b);
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  ::std::string* unsafe_arena_release_b();
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  void unsafe_arena_set_allocated_b(
      ::std::string* b);

  // optional int32 a = 5;
  bool has_a() const;
  void clear_a();
  static const int kAFieldNumber = 5;
  ::google::protobuf::int32 a() const;
  void set_a(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestOneofBackwardsCompatible.FooGroup)
 private:
  void set_has_a();
  void clear_has_a();
  void set_has_b();
  void clear_has_b();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr b_;
  ::google::protobuf::int32 a_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class TestOneofBackwardsCompatible : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.TestOneofBackwardsCompatible) */ {
 public:
  TestOneofBackwardsCompatible();
  virtual ~TestOneofBackwardsCompatible();

  TestOneofBackwardsCompatible(const TestOneofBackwardsCompatible& from);

  inline TestOneofBackwardsCompatible& operator=(const TestOneofBackwardsCompatible& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TestOneofBackwardsCompatible(TestOneofBackwardsCompatible&& from) noexcept
    : TestOneofBackwardsCompatible() {
    *this = ::std::move(from);
  }

  inline TestOneofBackwardsCompatible& operator=(TestOneofBackwardsCompatible&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const TestOneofBackwardsCompatible& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TestOneofBackwardsCompatible* internal_default_instance() {
    return reinterpret_cast<const TestOneofBackwardsCompatible*>(
               &_TestOneofBackwardsCompatible_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    60;

  void UnsafeArenaSwap(TestOneofBackwardsCompatible* other);
  void Swap(TestOneofBackwardsCompatible* other);
  friend void swap(TestOneofBackwardsCompatible& a, TestOneofBackwardsCompatible& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline TestOneofBackwardsCompatible* New() const final {
    return CreateMaybeMessage<TestOneofBackwardsCompatible>(NULL);
  }

  TestOneofBackwardsCompatible* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestOneofBackwardsCompatible>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestOneofBackwardsCompatible& from);
  void MergeFrom(const TestOneofBackwardsCompatible& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TestOneofBackwardsCompatible* other);
  protected:
  explicit TestOneofBackwardsCompatible(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef TestOneofBackwardsCompatible_FooGroup FooGroup;

  // accessors -------------------------------------------------------

  // optional string foo_string = 2;
  bool has_foo_string() const;
  void clear_foo_string();
  static const int kFooStringFieldNumber = 2;
  const ::std::string& foo_string() const;
  void set_foo_string(const ::std::string& value);
  #if LANG_CXX11
  void set_foo_string(::std::string&& value);
  #endif
  void set_foo_string(const char* value);
  void set_foo_string(const char* value, size_t size);
  ::std::string* mutable_foo_string();
  ::std::string* release_foo_string();
  void set_allocated_foo_string(::std::string* foo_string);
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  ::std::string* unsafe_arena_release_foo_string();
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  void unsafe_arena_set_allocated_foo_string(
      ::std::string* foo_string);

  // optional .protobuf_unittest.TestAllTypes foo_message = 3;
  bool has_foo_message() const;
  void clear_foo_message();
  static const int kFooMessageFieldNumber = 3;
  private:
  const ::protobuf_unittest::TestAllTypes& _internal_foo_message() const;
  public:
  const ::protobuf_unittest::TestAllTypes& foo_message() const;
  ::protobuf_unittest::TestAllTypes* release_foo_message();
  ::protobuf_unittest::TestAllTypes* mutable_foo_message();
  void set_allocated_foo_message(::protobuf_unittest::TestAllTypes* foo_message);
  void unsafe_arena_set_allocated_foo_message(
      ::protobuf_unittest::TestAllTypes* foo_message);
  ::protobuf_unittest::TestAllTypes* unsafe_arena_release_foo_message();

  // optional group FooGroup = 4 { ... };
  bool has_foogroup() const;
  void clear_foogroup();
  static const int kFoogroupFieldNumber = 4;
  private:
  const ::protobuf_unittest::TestOneofBackwardsCompatible_FooGroup& _internal_foogroup() const;
  public:
  const ::protobuf_unittest::TestOneofBackwardsCompatible_FooGroup& foogroup() const;
  ::protobuf_unittest::TestOneofBackwardsCompatible_FooGroup* release_foogroup();
  ::protobuf_unittest::TestOneofBackwardsCompatible_FooGroup* mutable_foogroup();
  void set_allocated_foogroup(::protobuf_unittest::TestOneofBackwardsCompatible_FooGroup* foogroup);
  void unsafe_arena_set_allocated_foogroup(
      ::protobuf_unittest::TestOneofBackwardsCompatible_FooGroup* foogroup);
  ::protobuf_unittest::TestOneofBackwardsCompatible_FooGroup* unsafe_arena_release_foogroup();

  // optional int32 foo_int = 1;
  bool has_foo_int() const;
  void clear_foo_int();
  static const int kFooIntFieldNumber = 1;
  ::google::protobuf::int32 foo_int() const;
  void set_foo_int(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestOneofBackwardsCompatible)
 private:
  void set_has_foo_int();
  void clear_has_foo_int();
  void set_has_foo_string();
  void clear_has_foo_string();
  void set_has_foo_message();
  void clear_has_foo_message();
  void set_has_foogroup();
  void clear_has_foogroup();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr foo_string_;
  ::protobuf_unittest::TestAllTypes* foo_message_;
  ::protobuf_unittest::TestOneofBackwardsCompatible_FooGroup* foogroup_;
  ::google::protobuf::int32 foo_int_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class TestOneof2_FooGroup : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.TestOneof2.FooGroup) */ {
 public:
  TestOneof2_FooGroup();
  virtual ~TestOneof2_FooGroup();

  TestOneof2_FooGroup(const TestOneof2_FooGroup& from);

  inline TestOneof2_FooGroup& operator=(const TestOneof2_FooGroup& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TestOneof2_FooGroup(TestOneof2_FooGroup&& from) noexcept
    : TestOneof2_FooGroup() {
    *this = ::std::move(from);
  }

  inline TestOneof2_FooGroup& operator=(TestOneof2_FooGroup&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const TestOneof2_FooGroup& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TestOneof2_FooGroup* internal_default_instance() {
    return reinterpret_cast<const TestOneof2_FooGroup*>(
               &_TestOneof2_FooGroup_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    61;

  void UnsafeArenaSwap(TestOneof2_FooGroup* other);
  void Swap(TestOneof2_FooGroup* other);
  friend void swap(TestOneof2_FooGroup& a, TestOneof2_FooGroup& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline TestOneof2_FooGroup* New() const final {
    return CreateMaybeMessage<TestOneof2_FooGroup>(NULL);
  }

  TestOneof2_FooGroup* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestOneof2_FooGroup>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestOneof2_FooGroup& from);
  void MergeFrom(const TestOneof2_FooGroup& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TestOneof2_FooGroup* other);
  protected:
  explicit TestOneof2_FooGroup(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional string b = 10;
  bool has_b() const;
  void clear_b();
  static const int kBFieldNumber = 10;
  const ::std::string& b() const;
  void set_b(const ::std::string& value);
  #if LANG_CXX11
  void set_b(::std::string&& value);
  #endif
  void set_b(const char* value);
  void set_b(const char* value, size_t size);
  ::std::string* mutable_b();
  ::std::string* release_b();
  void set_allocated_b(::std::string* b);
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  ::std::string* unsafe_arena_release_b();
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  void unsafe_arena_set_allocated_b(
      ::std::string* b);

  // optional int32 a = 9;
  bool has_a() const;
  void clear_a();
  static const int kAFieldNumber = 9;
  ::google::protobuf::int32 a() const;
  void set_a(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestOneof2.FooGroup)
 private:
  void set_has_a();
  void clear_has_a();
  void set_has_b();
  void clear_has_b();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr b_;
  ::google::protobuf::int32 a_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class TestOneof2_NestedMessage : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.TestOneof2.NestedMessage) */ {
 public:
  TestOneof2_NestedMessage();
  virtual ~TestOneof2_NestedMessage();

  TestOneof2_NestedMessage(const TestOneof2_NestedMessage& from);

  inline TestOneof2_NestedMessage& operator=(const TestOneof2_NestedMessage& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TestOneof2_NestedMessage(TestOneof2_NestedMessage&& from) noexcept
    : TestOneof2_NestedMessage() {
    *this = ::std::move(from);
  }

  inline TestOneof2_NestedMessage& operator=(TestOneof2_NestedMessage&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const TestOneof2_NestedMessage& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TestOneof2_NestedMessage* internal_default_instance() {
    return reinterpret_cast<const TestOneof2_NestedMessage*>(
               &_TestOneof2_NestedMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    62;

  void UnsafeArenaSwap(TestOneof2_NestedMessage* other);
  void Swap(TestOneof2_NestedMessage* other);
  friend void swap(TestOneof2_NestedMessage& a, TestOneof2_NestedMessage& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline TestOneof2_NestedMessage* New() const final {
    return CreateMaybeMessage<TestOneof2_NestedMessage>(NULL);
  }

  TestOneof2_NestedMessage* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestOneof2_NestedMessage>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestOneof2_NestedMessage& from);
  void MergeFrom(const TestOneof2_NestedMessage& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TestOneof2_NestedMessage* other);
  protected:
  explicit TestOneof2_NestedMessage(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated int32 corge_int = 2;
  int corge_int_size() const;
  void clear_corge_int();
  static const int kCorgeIntFieldNumber = 2;
  ::google::protobuf::int32 corge_int(int index) const;
  void set_corge_int(int index, ::google::protobuf::int32 value);
  void add_corge_int(::google::protobuf::int32 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
      corge_int() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
      mutable_corge_int();

  // optional int64 qux_int = 1;
  bool has_qux_int() const;
  void clear_qux_int();
  static const int kQuxIntFieldNumber = 1;
  ::google::protobuf::int64 qux_int() const;
  void set_qux_int(::google::protobuf::int64 value);

  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestOneof2.NestedMessage)
 private:
  void set_has_qux_int();
  void clear_has_qux_int();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > corge_int_;
  ::google::protobuf::int64 qux_int_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class TestOneof2 : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.TestOneof2) */ {
 public:
  TestOneof2();
  virtual ~TestOneof2();

  TestOneof2(const TestOneof2& from);

  inline TestOneof2& operator=(const TestOneof2& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TestOneof2(TestOneof2&& from) noexcept
    : TestOneof2() {
    *this = ::std::move(from);
  }

  inline TestOneof2& operator=(TestOneof2&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const TestOneof2& default_instance();

  enum FooCase {
    kFooInt = 1,
    kFooString = 2,
    kFooCord = 3,
    kFooStringPiece = 4,
    kFooBytes = 5,
    kFooEnum = 6,
    kFooMessage = 7,
    kFoogroup = 8,
    kFooLazyMessage = 11,
    FOO_NOT_SET = 0,
  };

  enum BarCase {
    kBarInt = 12,
    kBarString = 13,
    kBarCord = 14,
    kBarStringPiece = 15,
    kBarBytes = 16,
    kBarEnum = 17,
    BAR_NOT_SET = 0,
  };

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TestOneof2* internal_default_instance() {
    return reinterpret_cast<const TestOneof2*>(
               &_TestOneof2_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    63;

  void UnsafeArenaSwap(TestOneof2* other);
  void Swap(TestOneof2* other);
  friend void swap(TestOneof2& a, TestOneof2& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline TestOneof2* New() const final {
    return CreateMaybeMessage<TestOneof2>(NULL);
  }

  TestOneof2* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestOneof2>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestOneof2& from);
  void MergeFrom(const TestOneof2& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TestOneof2* other);
  protected:
  explicit TestOneof2(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef TestOneof2_FooGroup FooGroup;
  typedef TestOneof2_NestedMessage NestedMessage;

  typedef TestOneof2_NestedEnum NestedEnum;
  static const NestedEnum FOO =
    TestOneof2_NestedEnum_FOO;
  static const NestedEnum BAR =
    TestOneof2_NestedEnum_BAR;
  static const NestedEnum BAZ =
    TestOneof2_NestedEnum_BAZ;
  static inline bool NestedEnum_IsValid(int value) {
    return TestOneof2_NestedEnum_IsValid(value);
  }
  static const NestedEnum NestedEnum_MIN =
    TestOneof2_NestedEnum_NestedEnum_MIN;
  static const NestedEnum NestedEnum_MAX =
    TestOneof2_NestedEnum_NestedEnum_MAX;
  static const int NestedEnum_ARRAYSIZE =
    TestOneof2_NestedEnum_NestedEnum_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  NestedEnum_descriptor() {
    return TestOneof2_NestedEnum_descriptor();
  }
  static inline const ::std::string& NestedEnum_Name(NestedEnum value) {
    return TestOneof2_NestedEnum_Name(value);
  }
  static inline bool NestedEnum_Parse(const ::std::string& name,
      NestedEnum* value) {
    return TestOneof2_NestedEnum_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  // optional string baz_string = 19 [default = "BAZ"];
  bool has_baz_string() const;
  void clear_baz_string();
  static const int kBazStringFieldNumber = 19;
  const ::std::string& baz_string() const;
  void set_baz_string(const ::std::string& value);
  #if LANG_CXX11
  void set_baz_string(::std::string&& value);
  #endif
  void set_baz_string(const char* value);
  void set_baz_string(const char* value, size_t size);
  ::std::string* mutable_baz_string();
  ::std::string* release_baz_string();
  void set_allocated_baz_string(::std::string* baz_string);
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  ::std::string* unsafe_arena_release_baz_string();
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  void unsafe_arena_set_allocated_baz_string(
      ::std::string* baz_string);

  // optional int32 baz_int = 18;
  bool has_baz_int() const;
  void clear_baz_int();
  static const int kBazIntFieldNumber = 18;
  ::google::protobuf::int32 baz_int() const;
  void set_baz_int(::google::protobuf::int32 value);

  // optional int32 foo_int = 1;
  bool has_foo_int() const;
  void clear_foo_int();
  static const int kFooIntFieldNumber = 1;
  ::google::protobuf::int32 foo_int() const;
  void set_foo_int(::google::protobuf::int32 value);

  // optional string foo_string = 2;
  bool has_foo_string() const;
  void clear_foo_string();
  static const int kFooStringFieldNumber = 2;
  const ::std::string& foo_string() const;
  void set_foo_string(const ::std::string& value);
  #if LANG_CXX11
  void set_foo_string(::std::string&& value);
  #endif
  void set_foo_string(const char* value);
  void set_foo_string(const char* value, size_t size);
  ::std::string* mutable_foo_string();
  ::std::string* release_foo_string();
  void set_allocated_foo_string(::std::string* foo_string);
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  ::std::string* unsafe_arena_release_foo_string();
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  void unsafe_arena_set_allocated_foo_string(
      ::std::string* foo_string);

  // optional string foo_cord = 3 [ctype = CORD];
  bool has_foo_cord() const;
  void clear_foo_cord();
  static const int kFooCordFieldNumber = 3;
 private:
  // Hidden due to unknown ctype option.
  const ::std::string& foo_cord() const;
  void set_foo_cord(const ::std::string& value);
  #if LANG_CXX11
  void set_foo_cord(::std::string&& value);
  #endif
  void set_foo_cord(const char* value);
  void set_foo_cord(const char* value, size_t size);
  ::std::string* mutable_foo_cord();
  ::std::string* release_foo_cord();
  void set_allocated_foo_cord(::std::string* foo_cord);
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  ::std::string* unsafe_arena_release_foo_cord();
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  void unsafe_arena_set_allocated_foo_cord(
      ::std::string* foo_cord);
 public:

  // optional string foo_string_piece = 4 [ctype = STRING_PIECE];
  bool has_foo_string_piece() const;
  void clear_foo_string_piece();
  static const int kFooStringPieceFieldNumber = 4;
 private:
  // Hidden due to unknown ctype option.
  const ::std::string& foo_string_piece() const;
  void set_foo_string_piece(const ::std::string& value);
  #if LANG_CXX11
  void set_foo_string_piece(::std::string&& value);
  #endif
  void set_foo_string_piece(const char* value);
  void set_foo_string_piece(const char* value, size_t size);
  ::std::string* mutable_foo_string_piece();
  ::std::string* release_foo_string_piece();
  void set_allocated_foo_string_piece(::std::string* foo_string_piece);
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  ::std::string* unsafe_arena_release_foo_string_piece();
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  void unsafe_arena_set_allocated_foo_string_piece(
      ::std::string* foo_string_piece);
 public:

  // optional bytes foo_bytes = 5;
  bool has_foo_bytes() const;
  void clear_foo_bytes();
  static const int kFooBytesFieldNumber = 5;
  const ::std::string& foo_bytes() const;
  void set_foo_bytes(const ::std::string& value);
  #if LANG_CXX11
  void set_foo_bytes(::std::string&& value);
  #endif
  void set_foo_bytes(const char* value);
  void set_foo_bytes(const void* value, size_t size);
  ::std::string* mutable_foo_bytes();
  ::std::string* release_foo_bytes();
  void set_allocated_foo_bytes(::std::string* foo_bytes);
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  ::std::string* unsafe_arena_release_foo_bytes();
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  void unsafe_arena_set_allocated_foo_bytes(
      ::std::string* foo_bytes);

  // optional .protobuf_unittest.TestOneof2.NestedEnum foo_enum = 6;
  bool has_foo_enum() const;
  void clear_foo_enum();
  static const int kFooEnumFieldNumber = 6;
  ::protobuf_unittest::TestOneof2_NestedEnum foo_enum() const;
  void set_foo_enum(::protobuf_unittest::TestOneof2_NestedEnum value);

  // optional .protobuf_unittest.TestOneof2.NestedMessage foo_message = 7;
  bool has_foo_message() const;
  void clear_foo_message();
  static const int kFooMessageFieldNumber = 7;
  private:
  const ::protobuf_unittest::TestOneof2_NestedMessage& _internal_foo_message() const;
  public:
  const ::protobuf_unittest::TestOneof2_NestedMessage& foo_message() const;
  ::protobuf_unittest::TestOneof2_NestedMessage* release_foo_message();
  ::protobuf_unittest::TestOneof2_NestedMessage* mutable_foo_message();
  void set_allocated_foo_message(::protobuf_unittest::TestOneof2_NestedMessage* foo_message);
  void unsafe_arena_set_allocated_foo_message(
      ::protobuf_unittest::TestOneof2_NestedMessage* foo_message);
  ::protobuf_unittest::TestOneof2_NestedMessage* unsafe_arena_release_foo_message();

  // optional group FooGroup = 8 { ... };
  bool has_foogroup() const;
  void clear_foogroup();
  static const int kFoogroupFieldNumber = 8;
  private:
  const ::protobuf_unittest::TestOneof2_FooGroup& _internal_foogroup() const;
  public:
  const ::protobuf_unittest::TestOneof2_FooGroup& foogroup() const;
  ::protobuf_unittest::TestOneof2_FooGroup* release_foogroup();
  ::protobuf_unittest::TestOneof2_FooGroup* mutable_foogroup();
  void set_allocated_foogroup(::protobuf_unittest::TestOneof2_FooGroup* foogroup);
  void unsafe_arena_set_allocated_foogroup(
      ::protobuf_unittest::TestOneof2_FooGroup* foogroup);
  ::protobuf_unittest::TestOneof2_FooGroup* unsafe_arena_release_foogroup();

  // optional .protobuf_unittest.TestOneof2.NestedMessage foo_lazy_message = 11 [lazy = true];
  bool has_foo_lazy_message() const;
  void clear_foo_lazy_message();
  static const int kFooLazyMessageFieldNumber = 11;
  private:
  const ::protobuf_unittest::TestOneof2_NestedMessage& _internal_foo_lazy_message() const;
  public:
  const ::protobuf_unittest::TestOneof2_NestedMessage& foo_lazy_message() const;
  ::protobuf_unittest::TestOneof2_NestedMessage* release_foo_lazy_message();
  ::protobuf_unittest::TestOneof2_NestedMessage* mutable_foo_lazy_message();
  void set_allocated_foo_lazy_message(::protobuf_unittest::TestOneof2_NestedMessage* foo_lazy_message);
  void unsafe_arena_set_allocated_foo_lazy_message(
      ::protobuf_unittest::TestOneof2_NestedMessage* foo_lazy_message);
  ::protobuf_unittest::TestOneof2_NestedMessage* unsafe_arena_release_foo_lazy_message();

  // optional int32 bar_int = 12 [default = 5];
  bool has_bar_int() const;
  void clear_bar_int();
  static const int kBarIntFieldNumber = 12;
  ::google::protobuf::int32 bar_int() const;
  void set_bar_int(::google::protobuf::int32 value);

  // optional string bar_string = 13 [default = "STRING"];
  bool has_bar_string() const;
  void clear_bar_string();
  static const int kBarStringFieldNumber = 13;
  const ::std::string& bar_string() const;
  void set_bar_string(const ::std::string& value);
  #if LANG_CXX11
  void set_bar_string(::std::string&& value);
  #endif
  void set_bar_string(const char* value);
  void set_bar_string(const char* value, size_t size);
  ::std::string* mutable_bar_string();
  ::std::string* release_bar_string();
  void set_allocated_bar_string(::std::string* bar_string);
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  ::std::string* unsafe_arena_release_bar_string();
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  void unsafe_arena_set_allocated_bar_string(
      ::std::string* bar_string);

  // optional string bar_cord = 14 [default = "CORD", ctype = CORD];
  bool has_bar_cord() const;
  void clear_bar_cord();
  static const int kBarCordFieldNumber = 14;
 private:
  // Hidden due to unknown ctype option.
  const ::std::string& bar_cord() const;
  void set_bar_cord(const ::std::string& value);
  #if LANG_CXX11
  void set_bar_cord(::std::string&& value);
  #endif
  void set_bar_cord(const char* value);
  void set_bar_cord(const char* value, size_t size);
  ::std::string* mutable_bar_cord();
  ::std::string* release_bar_cord();
  void set_allocated_bar_cord(::std::string* bar_cord);
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  ::std::string* unsafe_arena_release_bar_cord();
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  void unsafe_arena_set_allocated_bar_cord(
      ::std::string* bar_cord);
 public:

  // optional string bar_string_piece = 15 [default = "SPIECE", ctype = STRING_PIECE];
  bool has_bar_string_piece() const;
  void clear_bar_string_piece();
  static const int kBarStringPieceFieldNumber = 15;
 private:
  // Hidden due to unknown ctype option.
  const ::std::string& bar_string_piece() const;
  void set_bar_string_piece(const ::std::string& value);
  #if LANG_CXX11
  void set_bar_string_piece(::std::string&& value);
  #endif
  void set_bar_string_piece(const char* value);
  void set_bar_string_piece(const char* value, size_t size);
  ::std::string* mutable_bar_string_piece();
  ::std::string* release_bar_string_piece();
  void set_allocated_bar_string_piece(::std::string* bar_string_piece);
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  ::std::string* unsafe_arena_release_bar_string_piece();
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  void unsafe_arena_set_allocated_bar_string_piece(
      ::std::string* bar_string_piece);
 public:

  // optional bytes bar_bytes = 16 [default = "BYTES"];
  bool has_bar_bytes() const;
  void clear_bar_bytes();
  static const int kBarBytesFieldNumber = 16;
  const ::std::string& bar_bytes() const;
  void set_bar_bytes(const ::std::string& value);
  #if LANG_CXX11
  void set_bar_bytes(::std::string&& value);
  #endif
  void set_bar_bytes(const char* value);
  void set_bar_bytes(const void* value, size_t size);
  ::std::string* mutable_bar_bytes();
  ::std::string* release_bar_bytes();
  void set_allocated_bar_bytes(::std::string* bar_bytes);
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  ::std::string* unsafe_arena_release_bar_bytes();
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  void unsafe_arena_set_allocated_bar_bytes(
      ::std::string* bar_bytes);

  // optional .protobuf_unittest.TestOneof2.NestedEnum bar_enum = 17 [default = BAR];
  bool has_bar_enum() const;
  void clear_bar_enum();
  static const int kBarEnumFieldNumber = 17;
  ::protobuf_unittest::TestOneof2_NestedEnum bar_enum() const;
  void set_bar_enum(::protobuf_unittest::TestOneof2_NestedEnum value);

  void clear_foo();
  FooCase foo_case() const;
  void clear_bar();
  BarCase bar_case() const;
  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestOneof2)
 private:
  void set_has_foo_int();
  void set_has_foo_string();
  void set_has_foo_cord();
  void set_has_foo_string_piece();
  void set_has_foo_bytes();
  void set_has_foo_enum();
  void set_has_foo_message();
  void set_has_foogroup();
  void set_has_foo_lazy_message();
  void set_has_bar_int();
  void set_has_bar_string();
  void set_has_bar_cord();
  void set_has_bar_string_piece();
  void set_has_bar_bytes();
  void set_has_bar_enum();
  void set_has_baz_int();
  void clear_has_baz_int();
  void set_has_baz_string();
  void clear_has_baz_string();

  inline bool has_foo() const;
  inline void clear_has_foo();

  inline bool has_bar() const;
  inline void clear_has_bar();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  public:
  static ::google::protobuf::internal::ExplicitlyConstructed< ::std::string> _i_give_permission_to_break_this_code_default_baz_string_;
  private:
  ::google::protobuf::internal::ArenaStringPtr baz_string_;
  ::google::protobuf::int32 baz_int_;
  union FooUnion {
    FooUnion() {}
    ::google::protobuf::int32 foo_int_;
    ::google::protobuf::internal::ArenaStringPtr foo_string_;
    ::google::protobuf::internal::ArenaStringPtr foo_cord_;
    ::google::protobuf::internal::ArenaStringPtr foo_string_piece_;
    ::google::protobuf::internal::ArenaStringPtr foo_bytes_;
    int foo_enum_;
    ::protobuf_unittest::TestOneof2_NestedMessage* foo_message_;
    ::protobuf_unittest::TestOneof2_FooGroup* foogroup_;
    ::protobuf_unittest::TestOneof2_NestedMessage* foo_lazy_message_;
  } foo_;
  union BarUnion {
    BarUnion() {}
    ::google::protobuf::int32 bar_int_;
    ::google::protobuf::internal::ArenaStringPtr bar_string_;
    ::google::protobuf::internal::ArenaStringPtr bar_cord_;
    ::google::protobuf::internal::ArenaStringPtr bar_string_piece_;
    ::google::protobuf::internal::ArenaStringPtr bar_bytes_;
    int bar_enum_;
  } bar_;
  public:
  static ::google::protobuf::internal::ExplicitlyConstructed< ::std::string> _i_give_permission_to_break_this_code_default_bar_string_;
  private:
  public:
  static ::google::protobuf::internal::ExplicitlyConstructed< ::std::string> _i_give_permission_to_break_this_code_default_bar_cord_;
  private:
  public:
  static ::google::protobuf::internal::ExplicitlyConstructed< ::std::string> _i_give_permission_to_break_this_code_default_bar_string_piece_;
  private:
  public:
  static ::google::protobuf::internal::ExplicitlyConstructed< ::std::string> _i_give_permission_to_break_this_code_default_bar_bytes_;
  private:
  ::google::protobuf::uint32 _oneof_case_[2];

  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class TestRequiredOneof_NestedMessage : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.TestRequiredOneof.NestedMessage) */ {
 public:
  TestRequiredOneof_NestedMessage();
  virtual ~TestRequiredOneof_NestedMessage();

  TestRequiredOneof_NestedMessage(const TestRequiredOneof_NestedMessage& from);

  inline TestRequiredOneof_NestedMessage& operator=(const TestRequiredOneof_NestedMessage& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TestRequiredOneof_NestedMessage(TestRequiredOneof_NestedMessage&& from) noexcept
    : TestRequiredOneof_NestedMessage() {
    *this = ::std::move(from);
  }

  inline TestRequiredOneof_NestedMessage& operator=(TestRequiredOneof_NestedMessage&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const TestRequiredOneof_NestedMessage& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TestRequiredOneof_NestedMessage* internal_default_instance() {
    return reinterpret_cast<const TestRequiredOneof_NestedMessage*>(
               &_TestRequiredOneof_NestedMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    64;

  void UnsafeArenaSwap(TestRequiredOneof_NestedMessage* other);
  void Swap(TestRequiredOneof_NestedMessage* other);
  friend void swap(TestRequiredOneof_NestedMessage& a, TestRequiredOneof_NestedMessage& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline TestRequiredOneof_NestedMessage* New() const final {
    return CreateMaybeMessage<TestRequiredOneof_NestedMessage>(NULL);
  }

  TestRequiredOneof_NestedMessage* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestRequiredOneof_NestedMessage>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestRequiredOneof_NestedMessage& from);
  void MergeFrom(const TestRequiredOneof_NestedMessage& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TestRequiredOneof_NestedMessage* other);
  protected:
  explicit TestRequiredOneof_NestedMessage(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // required double required_double = 1;
  bool has_required_double() const;
  void clear_required_double();
  static const int kRequiredDoubleFieldNumber = 1;
  double required_double() const;
  void set_required_double(double value);

  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestRequiredOneof.NestedMessage)
 private:
  void set_has_required_double();
  void clear_has_required_double();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  double required_double_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class TestRequiredOneof : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.TestRequiredOneof) */ {
 public:
  TestRequiredOneof();
  virtual ~TestRequiredOneof();

  TestRequiredOneof(const TestRequiredOneof& from);

  inline TestRequiredOneof& operator=(const TestRequiredOneof& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TestRequiredOneof(TestRequiredOneof&& from) noexcept
    : TestRequiredOneof() {
    *this = ::std::move(from);
  }

  inline TestRequiredOneof& operator=(TestRequiredOneof&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const TestRequiredOneof& default_instance();

  enum FooCase {
    kFooInt = 1,
    kFooString = 2,
    kFooMessage = 3,
    FOO_NOT_SET = 0,
  };

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TestRequiredOneof* internal_default_instance() {
    return reinterpret_cast<const TestRequiredOneof*>(
               &_TestRequiredOneof_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    65;

  void UnsafeArenaSwap(TestRequiredOneof* other);
  void Swap(TestRequiredOneof* other);
  friend void swap(TestRequiredOneof& a, TestRequiredOneof& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline TestRequiredOneof* New() const final {
    return CreateMaybeMessage<TestRequiredOneof>(NULL);
  }

  TestRequiredOneof* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestRequiredOneof>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestRequiredOneof& from);
  void MergeFrom(const TestRequiredOneof& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TestRequiredOneof* other);
  protected:
  explicit TestRequiredOneof(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef TestRequiredOneof_NestedMessage NestedMessage;

  // accessors -------------------------------------------------------

  // optional int32 foo_int = 1;
  bool has_foo_int() const;
  void clear_foo_int();
  static const int kFooIntFieldNumber = 1;
  ::google::protobuf::int32 foo_int() const;
  void set_foo_int(::google::protobuf::int32 value);

  // optional string foo_string = 2;
  bool has_foo_string() const;
  void clear_foo_string();
  static const int kFooStringFieldNumber = 2;
  const ::std::string& foo_string() const;
  void set_foo_string(const ::std::string& value);
  #if LANG_CXX11
  void set_foo_string(::std::string&& value);
  #endif
  void set_foo_string(const char* value);
  void set_foo_string(const char* value, size_t size);
  ::std::string* mutable_foo_string();
  ::std::string* release_foo_string();
  void set_allocated_foo_string(::std::string* foo_string);
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  ::std::string* unsafe_arena_release_foo_string();
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  void unsafe_arena_set_allocated_foo_string(
      ::std::string* foo_string);

  // optional .protobuf_unittest.TestRequiredOneof.NestedMessage foo_message = 3;
  bool has_foo_message() const;
  void clear_foo_message();
  static const int kFooMessageFieldNumber = 3;
  private:
  const ::protobuf_unittest::TestRequiredOneof_NestedMessage& _internal_foo_message() const;
  public:
  const ::protobuf_unittest::TestRequiredOneof_NestedMessage& foo_message() const;
  ::protobuf_unittest::TestRequiredOneof_NestedMessage* release_foo_message();
  ::protobuf_unittest::TestRequiredOneof_NestedMessage* mutable_foo_message();
  void set_allocated_foo_message(::protobuf_unittest::TestRequiredOneof_NestedMessage* foo_message);
  void unsafe_arena_set_allocated_foo_message(
      ::protobuf_unittest::TestRequiredOneof_NestedMessage* foo_message);
  ::protobuf_unittest::TestRequiredOneof_NestedMessage* unsafe_arena_release_foo_message();

  void clear_foo();
  FooCase foo_case() const;
  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestRequiredOneof)
 private:
  void set_has_foo_int();
  void set_has_foo_string();
  void set_has_foo_message();

  inline bool has_foo() const;
  inline void clear_has_foo();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  union FooUnion {
    FooUnion() {}
    ::google::protobuf::int32 foo_int_;
    ::google::protobuf::internal::ArenaStringPtr foo_string_;
    ::protobuf_unittest::TestRequiredOneof_NestedMessage* foo_message_;
  } foo_;
  ::google::protobuf::uint32 _oneof_case_[1];

  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class TestPackedTypes : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.TestPackedTypes) */ {
 public:
  TestPackedTypes();
  virtual ~TestPackedTypes();

  TestPackedTypes(const TestPackedTypes& from);

  inline TestPackedTypes& operator=(const TestPackedTypes& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TestPackedTypes(TestPackedTypes&& from) noexcept
    : TestPackedTypes() {
    *this = ::std::move(from);
  }

  inline TestPackedTypes& operator=(TestPackedTypes&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const TestPackedTypes& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TestPackedTypes* internal_default_instance() {
    return reinterpret_cast<const TestPackedTypes*>(
               &_TestPackedTypes_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    66;

  void UnsafeArenaSwap(TestPackedTypes* other);
  void Swap(TestPackedTypes* other);
  friend void swap(TestPackedTypes& a, TestPackedTypes& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline TestPackedTypes* New() const final {
    return CreateMaybeMessage<TestPackedTypes>(NULL);
  }

  TestPackedTypes* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestPackedTypes>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestPackedTypes& from);
  void MergeFrom(const TestPackedTypes& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TestPackedTypes* other);
  protected:
  explicit TestPackedTypes(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated int32 packed_int32 = 90 [packed = true];
  int packed_int32_size() const;
  void clear_packed_int32();
  static const int kPackedInt32FieldNumber = 90;
  ::google::protobuf::int32 packed_int32(int index) const;
  void set_packed_int32(int index, ::google::protobuf::int32 value);
  void add_packed_int32(::google::protobuf::int32 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
      packed_int32() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
      mutable_packed_int32();

  // repeated int64 packed_int64 = 91 [packed = true];
  int packed_int64_size() const;
  void clear_packed_int64();
  static const int kPackedInt64FieldNumber = 91;
  ::google::protobuf::int64 packed_int64(int index) const;
  void set_packed_int64(int index, ::google::protobuf::int64 value);
  void add_packed_int64(::google::protobuf::int64 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
      packed_int64() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
      mutable_packed_int64();

  // repeated uint32 packed_uint32 = 92 [packed = true];
  int packed_uint32_size() const;
  void clear_packed_uint32();
  static const int kPackedUint32FieldNumber = 92;
  ::google::protobuf::uint32 packed_uint32(int index) const;
  void set_packed_uint32(int index, ::google::protobuf::uint32 value);
  void add_packed_uint32(::google::protobuf::uint32 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
      packed_uint32() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
      mutable_packed_uint32();

  // repeated uint64 packed_uint64 = 93 [packed = true];
  int packed_uint64_size() const;
  void clear_packed_uint64();
  static const int kPackedUint64FieldNumber = 93;
  ::google::protobuf::uint64 packed_uint64(int index) const;
  void set_packed_uint64(int index, ::google::protobuf::uint64 value);
  void add_packed_uint64(::google::protobuf::uint64 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >&
      packed_uint64() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >*
      mutable_packed_uint64();

  // repeated sint32 packed_sint32 = 94 [packed = true];
  int packed_sint32_size() const;
  void clear_packed_sint32();
  static const int kPackedSint32FieldNumber = 94;
  ::google::protobuf::int32 packed_sint32(int index) const;
  void set_packed_sint32(int index, ::google::protobuf::int32 value);
  void add_packed_sint32(::google::protobuf::int32 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
      packed_sint32() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
      mutable_packed_sint32();

  // repeated sint64 packed_sint64 = 95 [packed = true];
  int packed_sint64_size() const;
  void clear_packed_sint64();
  static const int kPackedSint64FieldNumber = 95;
  ::google::protobuf::int64 packed_sint64(int index) const;
  void set_packed_sint64(int index, ::google::protobuf::int64 value);
  void add_packed_sint64(::google::protobuf::int64 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
      packed_sint64() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
      mutable_packed_sint64();

  // repeated fixed32 packed_fixed32 = 96 [packed = true];
  int packed_fixed32_size() const;
  void clear_packed_fixed32();
  static const int kPackedFixed32FieldNumber = 96;
  ::google::protobuf::uint32 packed_fixed32(int index) const;
  void set_packed_fixed32(int index, ::google::protobuf::uint32 value);
  void add_packed_fixed32(::google::protobuf::uint32 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
      packed_fixed32() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
      mutable_packed_fixed32();

  // repeated fixed64 packed_fixed64 = 97 [packed = true];
  int packed_fixed64_size() const;
  void clear_packed_fixed64();
  static const int kPackedFixed64FieldNumber = 97;
  ::google::protobuf::uint64 packed_fixed64(int index) const;
  void set_packed_fixed64(int index, ::google::protobuf::uint64 value);
  void add_packed_fixed64(::google::protobuf::uint64 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >&
      packed_fixed64() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >*
      mutable_packed_fixed64();

  // repeated sfixed32 packed_sfixed32 = 98 [packed = true];
  int packed_sfixed32_size() const;
  void clear_packed_sfixed32();
  static const int kPackedSfixed32FieldNumber = 98;
  ::google::protobuf::int32 packed_sfixed32(int index) const;
  void set_packed_sfixed32(int index, ::google::protobuf::int32 value);
  void add_packed_sfixed32(::google::protobuf::int32 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
      packed_sfixed32() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
      mutable_packed_sfixed32();

  // repeated sfixed64 packed_sfixed64 = 99 [packed = true];
  int packed_sfixed64_size() const;
  void clear_packed_sfixed64();
  static const int kPackedSfixed64FieldNumber = 99;
  ::google::protobuf::int64 packed_sfixed64(int index) const;
  void set_packed_sfixed64(int index, ::google::protobuf::int64 value);
  void add_packed_sfixed64(::google::protobuf::int64 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
      packed_sfixed64() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
      mutable_packed_sfixed64();

  // repeated float packed_float = 100 [packed = true];
  int packed_float_size() const;
  void clear_packed_float();
  static const int kPackedFloatFieldNumber = 100;
  float packed_float(int index) const;
  void set_packed_float(int index, float value);
  void add_packed_float(float value);
  const ::google::protobuf::RepeatedField< float >&
      packed_float() const;
  ::google::protobuf::RepeatedField< float >*
      mutable_packed_float();

  // repeated double packed_double = 101 [packed = true];
  int packed_double_size() const;
  void clear_packed_double();
  static const int kPackedDoubleFieldNumber = 101;
  double packed_double(int index) const;
  void set_packed_double(int index, double value);
  void add_packed_double(double value);
  const ::google::protobuf::RepeatedField< double >&
      packed_double() const;
  ::google::protobuf::RepeatedField< double >*
      mutable_packed_double();

  // repeated bool packed_bool = 102 [packed = true];
  int packed_bool_size() const;
  void clear_packed_bool();
  static const int kPackedBoolFieldNumber = 102;
  bool packed_bool(int index) const;
  void set_packed_bool(int index, bool value);
  void add_packed_bool(bool value);
  const ::google::protobuf::RepeatedField< bool >&
      packed_bool() const;
  ::google::protobuf::RepeatedField< bool >*
      mutable_packed_bool();

  // repeated .protobuf_unittest.ForeignEnum packed_enum = 103 [packed = true];
  int packed_enum_size() const;
  void clear_packed_enum();
  static const int kPackedEnumFieldNumber = 103;
  ::protobuf_unittest::ForeignEnum packed_enum(int index) const;
  void set_packed_enum(int index, ::protobuf_unittest::ForeignEnum value);
  void add_packed_enum(::protobuf_unittest::ForeignEnum value);
  const ::google::protobuf::RepeatedField<int>& packed_enum() const;
  ::google::protobuf::RepeatedField<int>* mutable_packed_enum();

  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestPackedTypes)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > packed_int32_;
  mutable int _packed_int32_cached_byte_size_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int64 > packed_int64_;
  mutable int _packed_int64_cached_byte_size_;
  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > packed_uint32_;
  mutable int _packed_uint32_cached_byte_size_;
  ::google::protobuf::RepeatedField< ::google::protobuf::uint64 > packed_uint64_;
  mutable int _packed_uint64_cached_byte_size_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > packed_sint32_;
  mutable int _packed_sint32_cached_byte_size_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int64 > packed_sint64_;
  mutable int _packed_sint64_cached_byte_size_;
  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > packed_fixed32_;
  mutable int _packed_fixed32_cached_byte_size_;
  ::google::protobuf::RepeatedField< ::google::protobuf::uint64 > packed_fixed64_;
  mutable int _packed_fixed64_cached_byte_size_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > packed_sfixed32_;
  mutable int _packed_sfixed32_cached_byte_size_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int64 > packed_sfixed64_;
  mutable int _packed_sfixed64_cached_byte_size_;
  ::google::protobuf::RepeatedField< float > packed_float_;
  mutable int _packed_float_cached_byte_size_;
  ::google::protobuf::RepeatedField< double > packed_double_;
  mutable int _packed_double_cached_byte_size_;
  ::google::protobuf::RepeatedField< bool > packed_bool_;
  mutable int _packed_bool_cached_byte_size_;
  ::google::protobuf::RepeatedField<int> packed_enum_;
  mutable int _packed_enum_cached_byte_size_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class TestUnpackedTypes : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.TestUnpackedTypes) */ {
 public:
  TestUnpackedTypes();
  virtual ~TestUnpackedTypes();

  TestUnpackedTypes(const TestUnpackedTypes& from);

  inline TestUnpackedTypes& operator=(const TestUnpackedTypes& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TestUnpackedTypes(TestUnpackedTypes&& from) noexcept
    : TestUnpackedTypes() {
    *this = ::std::move(from);
  }

  inline TestUnpackedTypes& operator=(TestUnpackedTypes&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const TestUnpackedTypes& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TestUnpackedTypes* internal_default_instance() {
    return reinterpret_cast<const TestUnpackedTypes*>(
               &_TestUnpackedTypes_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    67;

  void UnsafeArenaSwap(TestUnpackedTypes* other);
  void Swap(TestUnpackedTypes* other);
  friend void swap(TestUnpackedTypes& a, TestUnpackedTypes& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline TestUnpackedTypes* New() const final {
    return CreateMaybeMessage<TestUnpackedTypes>(NULL);
  }

  TestUnpackedTypes* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestUnpackedTypes>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestUnpackedTypes& from);
  void MergeFrom(const TestUnpackedTypes& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TestUnpackedTypes* other);
  protected:
  explicit TestUnpackedTypes(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated int32 unpacked_int32 = 90 [packed = false];
  int unpacked_int32_size() const;
  void clear_unpacked_int32();
  static const int kUnpackedInt32FieldNumber = 90;
  ::google::protobuf::int32 unpacked_int32(int index) const;
  void set_unpacked_int32(int index, ::google::protobuf::int32 value);
  void add_unpacked_int32(::google::protobuf::int32 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
      unpacked_int32() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
      mutable_unpacked_int32();

  // repeated int64 unpacked_int64 = 91 [packed = false];
  int unpacked_int64_size() const;
  void clear_unpacked_int64();
  static const int kUnpackedInt64FieldNumber = 91;
  ::google::protobuf::int64 unpacked_int64(int index) const;
  void set_unpacked_int64(int index, ::google::protobuf::int64 value);
  void add_unpacked_int64(::google::protobuf::int64 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
      unpacked_int64() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
      mutable_unpacked_int64();

  // repeated uint32 unpacked_uint32 = 92 [packed = false];
  int unpacked_uint32_size() const;
  void clear_unpacked_uint32();
  static const int kUnpackedUint32FieldNumber = 92;
  ::google::protobuf::uint32 unpacked_uint32(int index) const;
  void set_unpacked_uint32(int index, ::google::protobuf::uint32 value);
  void add_unpacked_uint32(::google::protobuf::uint32 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
      unpacked_uint32() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
      mutable_unpacked_uint32();

  // repeated uint64 unpacked_uint64 = 93 [packed = false];
  int unpacked_uint64_size() const;
  void clear_unpacked_uint64();
  static const int kUnpackedUint64FieldNumber = 93;
  ::google::protobuf::uint64 unpacked_uint64(int index) const;
  void set_unpacked_uint64(int index, ::google::protobuf::uint64 value);
  void add_unpacked_uint64(::google::protobuf::uint64 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >&
      unpacked_uint64() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >*
      mutable_unpacked_uint64();

  // repeated sint32 unpacked_sint32 = 94 [packed = false];
  int unpacked_sint32_size() const;
  void clear_unpacked_sint32();
  static const int kUnpackedSint32FieldNumber = 94;
  ::google::protobuf::int32 unpacked_sint32(int index) const;
  void set_unpacked_sint32(int index, ::google::protobuf::int32 value);
  void add_unpacked_sint32(::google::protobuf::int32 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
      unpacked_sint32() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
      mutable_unpacked_sint32();

  // repeated sint64 unpacked_sint64 = 95 [packed = false];
  int unpacked_sint64_size() const;
  void clear_unpacked_sint64();
  static const int kUnpackedSint64FieldNumber = 95;
  ::google::protobuf::int64 unpacked_sint64(int index) const;
  void set_unpacked_sint64(int index, ::google::protobuf::int64 value);
  void add_unpacked_sint64(::google::protobuf::int64 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
      unpacked_sint64() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
      mutable_unpacked_sint64();

  // repeated fixed32 unpacked_fixed32 = 96 [packed = false];
  int unpacked_fixed32_size() const;
  void clear_unpacked_fixed32();
  static const int kUnpackedFixed32FieldNumber = 96;
  ::google::protobuf::uint32 unpacked_fixed32(int index) const;
  void set_unpacked_fixed32(int index, ::google::protobuf::uint32 value);
  void add_unpacked_fixed32(::google::protobuf::uint32 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
      unpacked_fixed32() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
      mutable_unpacked_fixed32();

  // repeated fixed64 unpacked_fixed64 = 97 [packed = false];
  int unpacked_fixed64_size() const;
  void clear_unpacked_fixed64();
  static const int kUnpackedFixed64FieldNumber = 97;
  ::google::protobuf::uint64 unpacked_fixed64(int index) const;
  void set_unpacked_fixed64(int index, ::google::protobuf::uint64 value);
  void add_unpacked_fixed64(::google::protobuf::uint64 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >&
      unpacked_fixed64() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >*
      mutable_unpacked_fixed64();

  // repeated sfixed32 unpacked_sfixed32 = 98 [packed = false];
  int unpacked_sfixed32_size() const;
  void clear_unpacked_sfixed32();
  static const int kUnpackedSfixed32FieldNumber = 98;
  ::google::protobuf::int32 unpacked_sfixed32(int index) const;
  void set_unpacked_sfixed32(int index, ::google::protobuf::int32 value);
  void add_unpacked_sfixed32(::google::protobuf::int32 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
      unpacked_sfixed32() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
      mutable_unpacked_sfixed32();

  // repeated sfixed64 unpacked_sfixed64 = 99 [packed = false];
  int unpacked_sfixed64_size() const;
  void clear_unpacked_sfixed64();
  static const int kUnpackedSfixed64FieldNumber = 99;
  ::google::protobuf::int64 unpacked_sfixed64(int index) const;
  void set_unpacked_sfixed64(int index, ::google::protobuf::int64 value);
  void add_unpacked_sfixed64(::google::protobuf::int64 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
      unpacked_sfixed64() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
      mutable_unpacked_sfixed64();

  // repeated float unpacked_float = 100 [packed = false];
  int unpacked_float_size() const;
  void clear_unpacked_float();
  static const int kUnpackedFloatFieldNumber = 100;
  float unpacked_float(int index) const;
  void set_unpacked_float(int index, float value);
  void add_unpacked_float(float value);
  const ::google::protobuf::RepeatedField< float >&
      unpacked_float() const;
  ::google::protobuf::RepeatedField< float >*
      mutable_unpacked_float();

  // repeated double unpacked_double = 101 [packed = false];
  int unpacked_double_size() const;
  void clear_unpacked_double();
  static const int kUnpackedDoubleFieldNumber = 101;
  double unpacked_double(int index) const;
  void set_unpacked_double(int index, double value);
  void add_unpacked_double(double value);
  const ::google::protobuf::RepeatedField< double >&
      unpacked_double() const;
  ::google::protobuf::RepeatedField< double >*
      mutable_unpacked_double();

  // repeated bool unpacked_bool = 102 [packed = false];
  int unpacked_bool_size() const;
  void clear_unpacked_bool();
  static const int kUnpackedBoolFieldNumber = 102;
  bool unpacked_bool(int index) const;
  void set_unpacked_bool(int index, bool value);
  void add_unpacked_bool(bool value);
  const ::google::protobuf::RepeatedField< bool >&
      unpacked_bool() const;
  ::google::protobuf::RepeatedField< bool >*
      mutable_unpacked_bool();

  // repeated .protobuf_unittest.ForeignEnum unpacked_enum = 103 [packed = false];
  int unpacked_enum_size() const;
  void clear_unpacked_enum();
  static const int kUnpackedEnumFieldNumber = 103;
  ::protobuf_unittest::ForeignEnum unpacked_enum(int index) const;
  void set_unpacked_enum(int index, ::protobuf_unittest::ForeignEnum value);
  void add_unpacked_enum(::protobuf_unittest::ForeignEnum value);
  const ::google::protobuf::RepeatedField<int>& unpacked_enum() const;
  ::google::protobuf::RepeatedField<int>* mutable_unpacked_enum();

  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestUnpackedTypes)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > unpacked_int32_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int64 > unpacked_int64_;
  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > unpacked_uint32_;
  ::google::protobuf::RepeatedField< ::google::protobuf::uint64 > unpacked_uint64_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > unpacked_sint32_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int64 > unpacked_sint64_;
  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > unpacked_fixed32_;
  ::google::protobuf::RepeatedField< ::google::protobuf::uint64 > unpacked_fixed64_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > unpacked_sfixed32_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int64 > unpacked_sfixed64_;
  ::google::protobuf::RepeatedField< float > unpacked_float_;
  ::google::protobuf::RepeatedField< double > unpacked_double_;
  ::google::protobuf::RepeatedField< bool > unpacked_bool_;
  ::google::protobuf::RepeatedField<int> unpacked_enum_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class TestPackedExtensions : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.TestPackedExtensions) */ {
 public:
  TestPackedExtensions();
  virtual ~TestPackedExtensions();

  TestPackedExtensions(const TestPackedExtensions& from);

  inline TestPackedExtensions& operator=(const TestPackedExtensions& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TestPackedExtensions(TestPackedExtensions&& from) noexcept
    : TestPackedExtensions() {
    *this = ::std::move(from);
  }

  inline TestPackedExtensions& operator=(TestPackedExtensions&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const TestPackedExtensions& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TestPackedExtensions* internal_default_instance() {
    return reinterpret_cast<const TestPackedExtensions*>(
               &_TestPackedExtensions_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    68;

  void UnsafeArenaSwap(TestPackedExtensions* other);
  void Swap(TestPackedExtensions* other);
  friend void swap(TestPackedExtensions& a, TestPackedExtensions& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline TestPackedExtensions* New() const final {
    return CreateMaybeMessage<TestPackedExtensions>(NULL);
  }

  TestPackedExtensions* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestPackedExtensions>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestPackedExtensions& from);
  void MergeFrom(const TestPackedExtensions& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TestPackedExtensions* other);
  protected:
  explicit TestPackedExtensions(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(TestPackedExtensions)
  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestPackedExtensions)
 private:

  ::google::protobuf::internal::ExtensionSet _extensions_;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class TestUnpackedExtensions : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.TestUnpackedExtensions) */ {
 public:
  TestUnpackedExtensions();
  virtual ~TestUnpackedExtensions();

  TestUnpackedExtensions(const TestUnpackedExtensions& from);

  inline TestUnpackedExtensions& operator=(const TestUnpackedExtensions& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TestUnpackedExtensions(TestUnpackedExtensions&& from) noexcept
    : TestUnpackedExtensions() {
    *this = ::std::move(from);
  }

  inline TestUnpackedExtensions& operator=(TestUnpackedExtensions&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const TestUnpackedExtensions& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TestUnpackedExtensions* internal_default_instance() {
    return reinterpret_cast<const TestUnpackedExtensions*>(
               &_TestUnpackedExtensions_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    69;

  void UnsafeArenaSwap(TestUnpackedExtensions* other);
  void Swap(TestUnpackedExtensions* other);
  friend void swap(TestUnpackedExtensions& a, TestUnpackedExtensions& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline TestUnpackedExtensions* New() const final {
    return CreateMaybeMessage<TestUnpackedExtensions>(NULL);
  }

  TestUnpackedExtensions* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestUnpackedExtensions>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestUnpackedExtensions& from);
  void MergeFrom(const TestUnpackedExtensions& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TestUnpackedExtensions* other);
  protected:
  explicit TestUnpackedExtensions(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(TestUnpackedExtensions)
  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestUnpackedExtensions)
 private:

  ::google::protobuf::internal::ExtensionSet _extensions_;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class TestDynamicExtensions_DynamicMessageType : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.TestDynamicExtensions.DynamicMessageType) */ {
 public:
  TestDynamicExtensions_DynamicMessageType();
  virtual ~TestDynamicExtensions_DynamicMessageType();

  TestDynamicExtensions_DynamicMessageType(const TestDynamicExtensions_DynamicMessageType& from);

  inline TestDynamicExtensions_DynamicMessageType& operator=(const TestDynamicExtensions_DynamicMessageType& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TestDynamicExtensions_DynamicMessageType(TestDynamicExtensions_DynamicMessageType&& from) noexcept
    : TestDynamicExtensions_DynamicMessageType() {
    *this = ::std::move(from);
  }

  inline TestDynamicExtensions_DynamicMessageType& operator=(TestDynamicExtensions_DynamicMessageType&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const TestDynamicExtensions_DynamicMessageType& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TestDynamicExtensions_DynamicMessageType* internal_default_instance() {
    return reinterpret_cast<const TestDynamicExtensions_DynamicMessageType*>(
               &_TestDynamicExtensions_DynamicMessageType_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    70;

  void UnsafeArenaSwap(TestDynamicExtensions_DynamicMessageType* other);
  void Swap(TestDynamicExtensions_DynamicMessageType* other);
  friend void swap(TestDynamicExtensions_DynamicMessageType& a, TestDynamicExtensions_DynamicMessageType& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline TestDynamicExtensions_DynamicMessageType* New() const final {
    return CreateMaybeMessage<TestDynamicExtensions_DynamicMessageType>(NULL);
  }

  TestDynamicExtensions_DynamicMessageType* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestDynamicExtensions_DynamicMessageType>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestDynamicExtensions_DynamicMessageType& from);
  void MergeFrom(const TestDynamicExtensions_DynamicMessageType& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TestDynamicExtensions_DynamicMessageType* other);
  protected:
  explicit TestDynamicExtensions_DynamicMessageType(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional int32 dynamic_field = 2100;
  bool has_dynamic_field() const;
  void clear_dynamic_field();
  static const int kDynamicFieldFieldNumber = 2100;
  ::google::protobuf::int32 dynamic_field() const;
  void set_dynamic_field(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestDynamicExtensions.DynamicMessageType)
 private:
  void set_has_dynamic_field();
  void clear_has_dynamic_field();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::int32 dynamic_field_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class TestDynamicExtensions : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.TestDynamicExtensions) */ {
 public:
  TestDynamicExtensions();
  virtual ~TestDynamicExtensions();

  TestDynamicExtensions(const TestDynamicExtensions& from);

  inline TestDynamicExtensions& operator=(const TestDynamicExtensions& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TestDynamicExtensions(TestDynamicExtensions&& from) noexcept
    : TestDynamicExtensions() {
    *this = ::std::move(from);
  }

  inline TestDynamicExtensions& operator=(TestDynamicExtensions&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const TestDynamicExtensions& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TestDynamicExtensions* internal_default_instance() {
    return reinterpret_cast<const TestDynamicExtensions*>(
               &_TestDynamicExtensions_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    71;

  void UnsafeArenaSwap(TestDynamicExtensions* other);
  void Swap(TestDynamicExtensions* other);
  friend void swap(TestDynamicExtensions& a, TestDynamicExtensions& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline TestDynamicExtensions* New() const final {
    return CreateMaybeMessage<TestDynamicExtensions>(NULL);
  }

  TestDynamicExtensions* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestDynamicExtensions>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestDynamicExtensions& from);
  void MergeFrom(const TestDynamicExtensions& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TestDynamicExtensions* other);
  protected:
  explicit TestDynamicExtensions(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef TestDynamicExtensions_DynamicMessageType DynamicMessageType;

  typedef TestDynamicExtensions_DynamicEnumType DynamicEnumType;
  static const DynamicEnumType DYNAMIC_FOO =
    TestDynamicExtensions_DynamicEnumType_DYNAMIC_FOO;
  static const DynamicEnumType DYNAMIC_BAR =
    TestDynamicExtensions_DynamicEnumType_DYNAMIC_BAR;
  static const DynamicEnumType DYNAMIC_BAZ =
    TestDynamicExtensions_DynamicEnumType_DYNAMIC_BAZ;
  static inline bool DynamicEnumType_IsValid(int value) {
    return TestDynamicExtensions_DynamicEnumType_IsValid(value);
  }
  static const DynamicEnumType DynamicEnumType_MIN =
    TestDynamicExtensions_DynamicEnumType_DynamicEnumType_MIN;
  static const DynamicEnumType DynamicEnumType_MAX =
    TestDynamicExtensions_DynamicEnumType_DynamicEnumType_MAX;
  static const int DynamicEnumType_ARRAYSIZE =
    TestDynamicExtensions_DynamicEnumType_DynamicEnumType_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  DynamicEnumType_descriptor() {
    return TestDynamicExtensions_DynamicEnumType_descriptor();
  }
  static inline const ::std::string& DynamicEnumType_Name(DynamicEnumType value) {
    return TestDynamicExtensions_DynamicEnumType_Name(value);
  }
  static inline bool DynamicEnumType_Parse(const ::std::string& name,
      DynamicEnumType* value) {
    return TestDynamicExtensions_DynamicEnumType_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  // repeated string repeated_extension = 2005;
  int repeated_extension_size() const;
  void clear_repeated_extension();
  static const int kRepeatedExtensionFieldNumber = 2005;
  const ::std::string& repeated_extension(int index) const;
  ::std::string* mutable_repeated_extension(int index);
  void set_repeated_extension(int index, const ::std::string& value);
  #if LANG_CXX11
  void set_repeated_extension(int index, ::std::string&& value);
  #endif
  void set_repeated_extension(int index, const char* value);
  void set_repeated_extension(int index, const char* value, size_t size);
  ::std::string* add_repeated_extension();
  void add_repeated_extension(const ::std::string& value);
  #if LANG_CXX11
  void add_repeated_extension(::std::string&& value);
  #endif
  void add_repeated_extension(const char* value);
  void add_repeated_extension(const char* value, size_t size);
  const ::google::protobuf::RepeatedPtrField< ::std::string>& repeated_extension() const;
  ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_repeated_extension();

  // repeated sint32 packed_extension = 2006 [packed = true];
  int packed_extension_size() const;
  void clear_packed_extension();
  static const int kPackedExtensionFieldNumber = 2006;
  ::google::protobuf::int32 packed_extension(int index) const;
  void set_packed_extension(int index, ::google::protobuf::int32 value);
  void add_packed_extension(::google::protobuf::int32 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
      packed_extension() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
      mutable_packed_extension();

  // optional .protobuf_unittest.ForeignMessage message_extension = 2003;
  bool has_message_extension() const;
  void clear_message_extension();
  static const int kMessageExtensionFieldNumber = 2003;
  private:
  const ::protobuf_unittest::ForeignMessage& _internal_message_extension() const;
  public:
  const ::protobuf_unittest::ForeignMessage& message_extension() const;
  ::protobuf_unittest::ForeignMessage* release_message_extension();
  ::protobuf_unittest::ForeignMessage* mutable_message_extension();
  void set_allocated_message_extension(::protobuf_unittest::ForeignMessage* message_extension);
  void unsafe_arena_set_allocated_message_extension(
      ::protobuf_unittest::ForeignMessage* message_extension);
  ::protobuf_unittest::ForeignMessage* unsafe_arena_release_message_extension();

  // optional .protobuf_unittest.TestDynamicExtensions.DynamicMessageType dynamic_message_extension = 2004;
  bool has_dynamic_message_extension() const;
  void clear_dynamic_message_extension();
  static const int kDynamicMessageExtensionFieldNumber = 2004;
  private:
  const ::protobuf_unittest::TestDynamicExtensions_DynamicMessageType& _internal_dynamic_message_extension() const;
  public:
  const ::protobuf_unittest::TestDynamicExtensions_DynamicMessageType& dynamic_message_extension() const;
  ::protobuf_unittest::TestDynamicExtensions_DynamicMessageType* release_dynamic_message_extension();
  ::protobuf_unittest::TestDynamicExtensions_DynamicMessageType* mutable_dynamic_message_extension();
  void set_allocated_dynamic_message_extension(::protobuf_unittest::TestDynamicExtensions_DynamicMessageType* dynamic_message_extension);
  void unsafe_arena_set_allocated_dynamic_message_extension(
      ::protobuf_unittest::TestDynamicExtensions_DynamicMessageType* dynamic_message_extension);
  ::protobuf_unittest::TestDynamicExtensions_DynamicMessageType* unsafe_arena_release_dynamic_message_extension();

  // optional fixed32 scalar_extension = 2000;
  bool has_scalar_extension() const;
  void clear_scalar_extension();
  static const int kScalarExtensionFieldNumber = 2000;
  ::google::protobuf::uint32 scalar_extension() const;
  void set_scalar_extension(::google::protobuf::uint32 value);

  // optional .protobuf_unittest.ForeignEnum enum_extension = 2001;
  bool has_enum_extension() const;
  void clear_enum_extension();
  static const int kEnumExtensionFieldNumber = 2001;
  ::protobuf_unittest::ForeignEnum enum_extension() const;
  void set_enum_extension(::protobuf_unittest::ForeignEnum value);

  // optional .protobuf_unittest.TestDynamicExtensions.DynamicEnumType dynamic_enum_extension = 2002;
  bool has_dynamic_enum_extension() const;
  void clear_dynamic_enum_extension();
  static const int kDynamicEnumExtensionFieldNumber = 2002;
  ::protobuf_unittest::TestDynamicExtensions_DynamicEnumType dynamic_enum_extension() const;
  void set_dynamic_enum_extension(::protobuf_unittest::TestDynamicExtensions_DynamicEnumType value);

  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestDynamicExtensions)
 private:
  void set_has_scalar_extension();
  void clear_has_scalar_extension();
  void set_has_enum_extension();
  void clear_has_enum_extension();
  void set_has_dynamic_enum_extension();
  void clear_has_dynamic_enum_extension();
  void set_has_message_extension();
  void clear_has_message_extension();
  void set_has_dynamic_message_extension();
  void clear_has_dynamic_message_extension();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::RepeatedPtrField< ::std::string> repeated_extension_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > packed_extension_;
  mutable int _packed_extension_cached_byte_size_;
  ::protobuf_unittest::ForeignMessage* message_extension_;
  ::protobuf_unittest::TestDynamicExtensions_DynamicMessageType* dynamic_message_extension_;
  ::google::protobuf::uint32 scalar_extension_;
  int enum_extension_;
  int dynamic_enum_extension_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class TestRepeatedScalarDifferentTagSizes : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.TestRepeatedScalarDifferentTagSizes) */ {
 public:
  TestRepeatedScalarDifferentTagSizes();
  virtual ~TestRepeatedScalarDifferentTagSizes();

  TestRepeatedScalarDifferentTagSizes(const TestRepeatedScalarDifferentTagSizes& from);

  inline TestRepeatedScalarDifferentTagSizes& operator=(const TestRepeatedScalarDifferentTagSizes& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TestRepeatedScalarDifferentTagSizes(TestRepeatedScalarDifferentTagSizes&& from) noexcept
    : TestRepeatedScalarDifferentTagSizes() {
    *this = ::std::move(from);
  }

  inline TestRepeatedScalarDifferentTagSizes& operator=(TestRepeatedScalarDifferentTagSizes&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const TestRepeatedScalarDifferentTagSizes& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TestRepeatedScalarDifferentTagSizes* internal_default_instance() {
    return reinterpret_cast<const TestRepeatedScalarDifferentTagSizes*>(
               &_TestRepeatedScalarDifferentTagSizes_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    72;

  void UnsafeArenaSwap(TestRepeatedScalarDifferentTagSizes* other);
  void Swap(TestRepeatedScalarDifferentTagSizes* other);
  friend void swap(TestRepeatedScalarDifferentTagSizes& a, TestRepeatedScalarDifferentTagSizes& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline TestRepeatedScalarDifferentTagSizes* New() const final {
    return CreateMaybeMessage<TestRepeatedScalarDifferentTagSizes>(NULL);
  }

  TestRepeatedScalarDifferentTagSizes* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestRepeatedScalarDifferentTagSizes>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestRepeatedScalarDifferentTagSizes& from);
  void MergeFrom(const TestRepeatedScalarDifferentTagSizes& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TestRepeatedScalarDifferentTagSizes* other);
  protected:
  explicit TestRepeatedScalarDifferentTagSizes(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated fixed32 repeated_fixed32 = 12;
  int repeated_fixed32_size() const;
  void clear_repeated_fixed32();
  static const int kRepeatedFixed32FieldNumber = 12;
  ::google::protobuf::uint32 repeated_fixed32(int index) const;
  void set_repeated_fixed32(int index, ::google::protobuf::uint32 value);
  void add_repeated_fixed32(::google::protobuf::uint32 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
      repeated_fixed32() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
      mutable_repeated_fixed32();

  // repeated int32 repeated_int32 = 13;
  int repeated_int32_size() const;
  void clear_repeated_int32();
  static const int kRepeatedInt32FieldNumber = 13;
  ::google::protobuf::int32 repeated_int32(int index) const;
  void set_repeated_int32(int index, ::google::protobuf::int32 value);
  void add_repeated_int32(::google::protobuf::int32 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
      repeated_int32() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
      mutable_repeated_int32();

  // repeated fixed64 repeated_fixed64 = 2046;
  int repeated_fixed64_size() const;
  void clear_repeated_fixed64();
  static const int kRepeatedFixed64FieldNumber = 2046;
  ::google::protobuf::uint64 repeated_fixed64(int index) const;
  void set_repeated_fixed64(int index, ::google::protobuf::uint64 value);
  void add_repeated_fixed64(::google::protobuf::uint64 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >&
      repeated_fixed64() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >*
      mutable_repeated_fixed64();

  // repeated int64 repeated_int64 = 2047;
  int repeated_int64_size() const;
  void clear_repeated_int64();
  static const int kRepeatedInt64FieldNumber = 2047;
  ::google::protobuf::int64 repeated_int64(int index) const;
  void set_repeated_int64(int index, ::google::protobuf::int64 value);
  void add_repeated_int64(::google::protobuf::int64 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
      repeated_int64() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
      mutable_repeated_int64();

  // repeated float repeated_float = 262142;
  int repeated_float_size() const;
  void clear_repeated_float();
  static const int kRepeatedFloatFieldNumber = 262142;
  float repeated_float(int index) const;
  void set_repeated_float(int index, float value);
  void add_repeated_float(float value);
  const ::google::protobuf::RepeatedField< float >&
      repeated_float() const;
  ::google::protobuf::RepeatedField< float >*
      mutable_repeated_float();

  // repeated uint64 repeated_uint64 = 262143;
  int repeated_uint64_size() const;
  void clear_repeated_uint64();
  static const int kRepeatedUint64FieldNumber = 262143;
  ::google::protobuf::uint64 repeated_uint64(int index) const;
  void set_repeated_uint64(int index, ::google::protobuf::uint64 value);
  void add_repeated_uint64(::google::protobuf::uint64 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >&
      repeated_uint64() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >*
      mutable_repeated_uint64();

  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestRepeatedScalarDifferentTagSizes)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > repeated_fixed32_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > repeated_int32_;
  ::google::protobuf::RepeatedField< ::google::protobuf::uint64 > repeated_fixed64_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int64 > repeated_int64_;
  ::google::protobuf::RepeatedField< float > repeated_float_;
  ::google::protobuf::RepeatedField< ::google::protobuf::uint64 > repeated_uint64_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class TestParsingMerge_RepeatedFieldsGenerator_Group1 : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.TestParsingMerge.RepeatedFieldsGenerator.Group1) */ {
 public:
  TestParsingMerge_RepeatedFieldsGenerator_Group1();
  virtual ~TestParsingMerge_RepeatedFieldsGenerator_Group1();

  TestParsingMerge_RepeatedFieldsGenerator_Group1(const TestParsingMerge_RepeatedFieldsGenerator_Group1& from);

  inline TestParsingMerge_RepeatedFieldsGenerator_Group1& operator=(const TestParsingMerge_RepeatedFieldsGenerator_Group1& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TestParsingMerge_RepeatedFieldsGenerator_Group1(TestParsingMerge_RepeatedFieldsGenerator_Group1&& from) noexcept
    : TestParsingMerge_RepeatedFieldsGenerator_Group1() {
    *this = ::std::move(from);
  }

  inline TestParsingMerge_RepeatedFieldsGenerator_Group1& operator=(TestParsingMerge_RepeatedFieldsGenerator_Group1&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const TestParsingMerge_RepeatedFieldsGenerator_Group1& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TestParsingMerge_RepeatedFieldsGenerator_Group1* internal_default_instance() {
    return reinterpret_cast<const TestParsingMerge_RepeatedFieldsGenerator_Group1*>(
               &_TestParsingMerge_RepeatedFieldsGenerator_Group1_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    73;

  void UnsafeArenaSwap(TestParsingMerge_RepeatedFieldsGenerator_Group1* other);
  void Swap(TestParsingMerge_RepeatedFieldsGenerator_Group1* other);
  friend void swap(TestParsingMerge_RepeatedFieldsGenerator_Group1& a, TestParsingMerge_RepeatedFieldsGenerator_Group1& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline TestParsingMerge_RepeatedFieldsGenerator_Group1* New() const final {
    return CreateMaybeMessage<TestParsingMerge_RepeatedFieldsGenerator_Group1>(NULL);
  }

  TestParsingMerge_RepeatedFieldsGenerator_Group1* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestParsingMerge_RepeatedFieldsGenerator_Group1>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestParsingMerge_RepeatedFieldsGenerator_Group1& from);
  void MergeFrom(const TestParsingMerge_RepeatedFieldsGenerator_Group1& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TestParsingMerge_RepeatedFieldsGenerator_Group1* other);
  protected:
  explicit TestParsingMerge_RepeatedFieldsGenerator_Group1(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .protobuf_unittest.TestAllTypes field1 = 11;
  bool has_field1() const;
  void clear_field1();
  static const int kField1FieldNumber = 11;
  private:
  const ::protobuf_unittest::TestAllTypes& _internal_field1() const;
  public:
  const ::protobuf_unittest::TestAllTypes& field1() const;
  ::protobuf_unittest::TestAllTypes* release_field1();
  ::protobuf_unittest::TestAllTypes* mutable_field1();
  void set_allocated_field1(::protobuf_unittest::TestAllTypes* field1);
  void unsafe_arena_set_allocated_field1(
      ::protobuf_unittest::TestAllTypes* field1);
  ::protobuf_unittest::TestAllTypes* unsafe_arena_release_field1();

  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestParsingMerge.RepeatedFieldsGenerator.Group1)
 private:
  void set_has_field1();
  void clear_has_field1();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::protobuf_unittest::TestAllTypes* field1_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class TestParsingMerge_RepeatedFieldsGenerator_Group2 : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.TestParsingMerge.RepeatedFieldsGenerator.Group2) */ {
 public:
  TestParsingMerge_RepeatedFieldsGenerator_Group2();
  virtual ~TestParsingMerge_RepeatedFieldsGenerator_Group2();

  TestParsingMerge_RepeatedFieldsGenerator_Group2(const TestParsingMerge_RepeatedFieldsGenerator_Group2& from);

  inline TestParsingMerge_RepeatedFieldsGenerator_Group2& operator=(const TestParsingMerge_RepeatedFieldsGenerator_Group2& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TestParsingMerge_RepeatedFieldsGenerator_Group2(TestParsingMerge_RepeatedFieldsGenerator_Group2&& from) noexcept
    : TestParsingMerge_RepeatedFieldsGenerator_Group2() {
    *this = ::std::move(from);
  }

  inline TestParsingMerge_RepeatedFieldsGenerator_Group2& operator=(TestParsingMerge_RepeatedFieldsGenerator_Group2&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const TestParsingMerge_RepeatedFieldsGenerator_Group2& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TestParsingMerge_RepeatedFieldsGenerator_Group2* internal_default_instance() {
    return reinterpret_cast<const TestParsingMerge_RepeatedFieldsGenerator_Group2*>(
               &_TestParsingMerge_RepeatedFieldsGenerator_Group2_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    74;

  void UnsafeArenaSwap(TestParsingMerge_RepeatedFieldsGenerator_Group2* other);
  void Swap(TestParsingMerge_RepeatedFieldsGenerator_Group2* other);
  friend void swap(TestParsingMerge_RepeatedFieldsGenerator_Group2& a, TestParsingMerge_RepeatedFieldsGenerator_Group2& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline TestParsingMerge_RepeatedFieldsGenerator_Group2* New() const final {
    return CreateMaybeMessage<TestParsingMerge_RepeatedFieldsGenerator_Group2>(NULL);
  }

  TestParsingMerge_RepeatedFieldsGenerator_Group2* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestParsingMerge_RepeatedFieldsGenerator_Group2>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestParsingMerge_RepeatedFieldsGenerator_Group2& from);
  void MergeFrom(const TestParsingMerge_RepeatedFieldsGenerator_Group2& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TestParsingMerge_RepeatedFieldsGenerator_Group2* other);
  protected:
  explicit TestParsingMerge_RepeatedFieldsGenerator_Group2(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .protobuf_unittest.TestAllTypes field1 = 21;
  bool has_field1() const;
  void clear_field1();
  static const int kField1FieldNumber = 21;
  private:
  const ::protobuf_unittest::TestAllTypes& _internal_field1() const;
  public:
  const ::protobuf_unittest::TestAllTypes& field1() const;
  ::protobuf_unittest::TestAllTypes* release_field1();
  ::protobuf_unittest::TestAllTypes* mutable_field1();
  void set_allocated_field1(::protobuf_unittest::TestAllTypes* field1);
  void unsafe_arena_set_allocated_field1(
      ::protobuf_unittest::TestAllTypes* field1);
  ::protobuf_unittest::TestAllTypes* unsafe_arena_release_field1();

  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestParsingMerge.RepeatedFieldsGenerator.Group2)
 private:
  void set_has_field1();
  void clear_has_field1();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::protobuf_unittest::TestAllTypes* field1_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class TestParsingMerge_RepeatedFieldsGenerator : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.TestParsingMerge.RepeatedFieldsGenerator) */ {
 public:
  TestParsingMerge_RepeatedFieldsGenerator();
  virtual ~TestParsingMerge_RepeatedFieldsGenerator();

  TestParsingMerge_RepeatedFieldsGenerator(const TestParsingMerge_RepeatedFieldsGenerator& from);

  inline TestParsingMerge_RepeatedFieldsGenerator& operator=(const TestParsingMerge_RepeatedFieldsGenerator& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TestParsingMerge_RepeatedFieldsGenerator(TestParsingMerge_RepeatedFieldsGenerator&& from) noexcept
    : TestParsingMerge_RepeatedFieldsGenerator() {
    *this = ::std::move(from);
  }

  inline TestParsingMerge_RepeatedFieldsGenerator& operator=(TestParsingMerge_RepeatedFieldsGenerator&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const TestParsingMerge_RepeatedFieldsGenerator& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TestParsingMerge_RepeatedFieldsGenerator* internal_default_instance() {
    return reinterpret_cast<const TestParsingMerge_RepeatedFieldsGenerator*>(
               &_TestParsingMerge_RepeatedFieldsGenerator_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    75;

  void UnsafeArenaSwap(TestParsingMerge_RepeatedFieldsGenerator* other);
  void Swap(TestParsingMerge_RepeatedFieldsGenerator* other);
  friend void swap(TestParsingMerge_RepeatedFieldsGenerator& a, TestParsingMerge_RepeatedFieldsGenerator& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline TestParsingMerge_RepeatedFieldsGenerator* New() const final {
    return CreateMaybeMessage<TestParsingMerge_RepeatedFieldsGenerator>(NULL);
  }

  TestParsingMerge_RepeatedFieldsGenerator* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestParsingMerge_RepeatedFieldsGenerator>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestParsingMerge_RepeatedFieldsGenerator& from);
  void MergeFrom(const TestParsingMerge_RepeatedFieldsGenerator& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TestParsingMerge_RepeatedFieldsGenerator* other);
  protected:
  explicit TestParsingMerge_RepeatedFieldsGenerator(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef TestParsingMerge_RepeatedFieldsGenerator_Group1 Group1;
  typedef TestParsingMerge_RepeatedFieldsGenerator_Group2 Group2;

  // accessors -------------------------------------------------------

  // repeated .protobuf_unittest.TestAllTypes field1 = 1;
  int field1_size() const;
  void clear_field1();
  static const int kField1FieldNumber = 1;
  ::protobuf_unittest::TestAllTypes* mutable_field1(int index);
  ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::TestAllTypes >*
      mutable_field1();
  const ::protobuf_unittest::TestAllTypes& field1(int index) const;
  ::protobuf_unittest::TestAllTypes* add_field1();
  const ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::TestAllTypes >&
      field1() const;

  // repeated .protobuf_unittest.TestAllTypes field2 = 2;
  int field2_size() const;
  void clear_field2();
  static const int kField2FieldNumber = 2;
  ::protobuf_unittest::TestAllTypes* mutable_field2(int index);
  ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::TestAllTypes >*
      mutable_field2();
  const ::protobuf_unittest::TestAllTypes& field2(int index) const;
  ::protobuf_unittest::TestAllTypes* add_field2();
  const ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::TestAllTypes >&
      field2() const;

  // repeated .protobuf_unittest.TestAllTypes field3 = 3;
  int field3_size() const;
  void clear_field3();
  static const int kField3FieldNumber = 3;
  ::protobuf_unittest::TestAllTypes* mutable_field3(int index);
  ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::TestAllTypes >*
      mutable_field3();
  const ::protobuf_unittest::TestAllTypes& field3(int index) const;
  ::protobuf_unittest::TestAllTypes* add_field3();
  const ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::TestAllTypes >&
      field3() const;

  // repeated group Group1 = 10 { ... };
  int group1_size() const;
  void clear_group1();
  static const int kGroup1FieldNumber = 10;
  ::protobuf_unittest::TestParsingMerge_RepeatedFieldsGenerator_Group1* mutable_group1(int index);
  ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::TestParsingMerge_RepeatedFieldsGenerator_Group1 >*
      mutable_group1();
  const ::protobuf_unittest::TestParsingMerge_RepeatedFieldsGenerator_Group1& group1(int index) const;
  ::protobuf_unittest::TestParsingMerge_RepeatedFieldsGenerator_Group1* add_group1();
  const ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::TestParsingMerge_RepeatedFieldsGenerator_Group1 >&
      group1() const;

  // repeated group Group2 = 20 { ... };
  int group2_size() const;
  void clear_group2();
  static const int kGroup2FieldNumber = 20;
  ::protobuf_unittest::TestParsingMerge_RepeatedFieldsGenerator_Group2* mutable_group2(int index);
  ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::TestParsingMerge_RepeatedFieldsGenerator_Group2 >*
      mutable_group2();
  const ::protobuf_unittest::TestParsingMerge_RepeatedFieldsGenerator_Group2& group2(int index) const;
  ::protobuf_unittest::TestParsingMerge_RepeatedFieldsGenerator_Group2* add_group2();
  const ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::TestParsingMerge_RepeatedFieldsGenerator_Group2 >&
      group2() const;

  // repeated .protobuf_unittest.TestAllTypes ext1 = 1000;
  int ext1_size() const;
  void clear_ext1();
  static const int kExt1FieldNumber = 1000;
  ::protobuf_unittest::TestAllTypes* mutable_ext1(int index);
  ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::TestAllTypes >*
      mutable_ext1();
  const ::protobuf_unittest::TestAllTypes& ext1(int index) const;
  ::protobuf_unittest::TestAllTypes* add_ext1();
  const ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::TestAllTypes >&
      ext1() const;

  // repeated .protobuf_unittest.TestAllTypes ext2 = 1001;
  int ext2_size() const;
  void clear_ext2();
  static const int kExt2FieldNumber = 1001;
  ::protobuf_unittest::TestAllTypes* mutable_ext2(int index);
  ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::TestAllTypes >*
      mutable_ext2();
  const ::protobuf_unittest::TestAllTypes& ext2(int index) const;
  ::protobuf_unittest::TestAllTypes* add_ext2();
  const ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::TestAllTypes >&
      ext2() const;

  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestParsingMerge.RepeatedFieldsGenerator)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::TestAllTypes > field1_;
  ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::TestAllTypes > field2_;
  ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::TestAllTypes > field3_;
  ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::TestParsingMerge_RepeatedFieldsGenerator_Group1 > group1_;
  ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::TestParsingMerge_RepeatedFieldsGenerator_Group2 > group2_;
  ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::TestAllTypes > ext1_;
  ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::TestAllTypes > ext2_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class TestParsingMerge_OptionalGroup : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.TestParsingMerge.OptionalGroup) */ {
 public:
  TestParsingMerge_OptionalGroup();
  virtual ~TestParsingMerge_OptionalGroup();

  TestParsingMerge_OptionalGroup(const TestParsingMerge_OptionalGroup& from);

  inline TestParsingMerge_OptionalGroup& operator=(const TestParsingMerge_OptionalGroup& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TestParsingMerge_OptionalGroup(TestParsingMerge_OptionalGroup&& from) noexcept
    : TestParsingMerge_OptionalGroup() {
    *this = ::std::move(from);
  }

  inline TestParsingMerge_OptionalGroup& operator=(TestParsingMerge_OptionalGroup&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const TestParsingMerge_OptionalGroup& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TestParsingMerge_OptionalGroup* internal_default_instance() {
    return reinterpret_cast<const TestParsingMerge_OptionalGroup*>(
               &_TestParsingMerge_OptionalGroup_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    76;

  void UnsafeArenaSwap(TestParsingMerge_OptionalGroup* other);
  void Swap(TestParsingMerge_OptionalGroup* other);
  friend void swap(TestParsingMerge_OptionalGroup& a, TestParsingMerge_OptionalGroup& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline TestParsingMerge_OptionalGroup* New() const final {
    return CreateMaybeMessage<TestParsingMerge_OptionalGroup>(NULL);
  }

  TestParsingMerge_OptionalGroup* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestParsingMerge_OptionalGroup>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestParsingMerge_OptionalGroup& from);
  void MergeFrom(const TestParsingMerge_OptionalGroup& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TestParsingMerge_OptionalGroup* other);
  protected:
  explicit TestParsingMerge_OptionalGroup(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .protobuf_unittest.TestAllTypes optional_group_all_types = 11;
  bool has_optional_group_all_types() const;
  void clear_optional_group_all_types();
  static const int kOptionalGroupAllTypesFieldNumber = 11;
  private:
  const ::protobuf_unittest::TestAllTypes& _internal_optional_group_all_types() const;
  public:
  const ::protobuf_unittest::TestAllTypes& optional_group_all_types() const;
  ::protobuf_unittest::TestAllTypes* release_optional_group_all_types();
  ::protobuf_unittest::TestAllTypes* mutable_optional_group_all_types();
  void set_allocated_optional_group_all_types(::protobuf_unittest::TestAllTypes* optional_group_all_types);
  void unsafe_arena_set_allocated_optional_group_all_types(
      ::protobuf_unittest::TestAllTypes* optional_group_all_types);
  ::protobuf_unittest::TestAllTypes* unsafe_arena_release_optional_group_all_types();

  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestParsingMerge.OptionalGroup)
 private:
  void set_has_optional_group_all_types();
  void clear_has_optional_group_all_types();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::protobuf_unittest::TestAllTypes* optional_group_all_types_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class TestParsingMerge_RepeatedGroup : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.TestParsingMerge.RepeatedGroup) */ {
 public:
  TestParsingMerge_RepeatedGroup();
  virtual ~TestParsingMerge_RepeatedGroup();

  TestParsingMerge_RepeatedGroup(const TestParsingMerge_RepeatedGroup& from);

  inline TestParsingMerge_RepeatedGroup& operator=(const TestParsingMerge_RepeatedGroup& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TestParsingMerge_RepeatedGroup(TestParsingMerge_RepeatedGroup&& from) noexcept
    : TestParsingMerge_RepeatedGroup() {
    *this = ::std::move(from);
  }

  inline TestParsingMerge_RepeatedGroup& operator=(TestParsingMerge_RepeatedGroup&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const TestParsingMerge_RepeatedGroup& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TestParsingMerge_RepeatedGroup* internal_default_instance() {
    return reinterpret_cast<const TestParsingMerge_RepeatedGroup*>(
               &_TestParsingMerge_RepeatedGroup_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    77;

  void UnsafeArenaSwap(TestParsingMerge_RepeatedGroup* other);
  void Swap(TestParsingMerge_RepeatedGroup* other);
  friend void swap(TestParsingMerge_RepeatedGroup& a, TestParsingMerge_RepeatedGroup& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline TestParsingMerge_RepeatedGroup* New() const final {
    return CreateMaybeMessage<TestParsingMerge_RepeatedGroup>(NULL);
  }

  TestParsingMerge_RepeatedGroup* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestParsingMerge_RepeatedGroup>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestParsingMerge_RepeatedGroup& from);
  void MergeFrom(const TestParsingMerge_RepeatedGroup& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TestParsingMerge_RepeatedGroup* other);
  protected:
  explicit TestParsingMerge_RepeatedGroup(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .protobuf_unittest.TestAllTypes repeated_group_all_types = 21;
  bool has_repeated_group_all_types() const;
  void clear_repeated_group_all_types();
  static const int kRepeatedGroupAllTypesFieldNumber = 21;
  private:
  const ::protobuf_unittest::TestAllTypes& _internal_repeated_group_all_types() const;
  public:
  const ::protobuf_unittest::TestAllTypes& repeated_group_all_types() const;
  ::protobuf_unittest::TestAllTypes* release_repeated_group_all_types();
  ::protobuf_unittest::TestAllTypes* mutable_repeated_group_all_types();
  void set_allocated_repeated_group_all_types(::protobuf_unittest::TestAllTypes* repeated_group_all_types);
  void unsafe_arena_set_allocated_repeated_group_all_types(
      ::protobuf_unittest::TestAllTypes* repeated_group_all_types);
  ::protobuf_unittest::TestAllTypes* unsafe_arena_release_repeated_group_all_types();

  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestParsingMerge.RepeatedGroup)
 private:
  void set_has_repeated_group_all_types();
  void clear_has_repeated_group_all_types();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::protobuf_unittest::TestAllTypes* repeated_group_all_types_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class TestParsingMerge : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.TestParsingMerge) */ {
 public:
  TestParsingMerge();
  virtual ~TestParsingMerge();

  TestParsingMerge(const TestParsingMerge& from);

  inline TestParsingMerge& operator=(const TestParsingMerge& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TestParsingMerge(TestParsingMerge&& from) noexcept
    : TestParsingMerge() {
    *this = ::std::move(from);
  }

  inline TestParsingMerge& operator=(TestParsingMerge&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const TestParsingMerge& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TestParsingMerge* internal_default_instance() {
    return reinterpret_cast<const TestParsingMerge*>(
               &_TestParsingMerge_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    78;

  void UnsafeArenaSwap(TestParsingMerge* other);
  void Swap(TestParsingMerge* other);
  friend void swap(TestParsingMerge& a, TestParsingMerge& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline TestParsingMerge* New() const final {
    return CreateMaybeMessage<TestParsingMerge>(NULL);
  }

  TestParsingMerge* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestParsingMerge>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestParsingMerge& from);
  void MergeFrom(const TestParsingMerge& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TestParsingMerge* other);
  protected:
  explicit TestParsingMerge(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef TestParsingMerge_RepeatedFieldsGenerator RepeatedFieldsGenerator;
  typedef TestParsingMerge_OptionalGroup OptionalGroup;
  typedef TestParsingMerge_RepeatedGroup RepeatedGroup;

  // accessors -------------------------------------------------------

  // repeated .protobuf_unittest.TestAllTypes repeated_all_types = 3;
  int repeated_all_types_size() const;
  void clear_repeated_all_types();
  static const int kRepeatedAllTypesFieldNumber = 3;
  ::protobuf_unittest::TestAllTypes* mutable_repeated_all_types(int index);
  ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::TestAllTypes >*
      mutable_repeated_all_types();
  const ::protobuf_unittest::TestAllTypes& repeated_all_types(int index) const;
  ::protobuf_unittest::TestAllTypes* add_repeated_all_types();
  const ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::TestAllTypes >&
      repeated_all_types() const;

  // repeated group RepeatedGroup = 20 { ... };
  int repeatedgroup_size() const;
  void clear_repeatedgroup();
  static const int kRepeatedgroupFieldNumber = 20;
  ::protobuf_unittest::TestParsingMerge_RepeatedGroup* mutable_repeatedgroup(int index);
  ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::TestParsingMerge_RepeatedGroup >*
      mutable_repeatedgroup();
  const ::protobuf_unittest::TestParsingMerge_RepeatedGroup& repeatedgroup(int index) const;
  ::protobuf_unittest::TestParsingMerge_RepeatedGroup* add_repeatedgroup();
  const ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::TestParsingMerge_RepeatedGroup >&
      repeatedgroup() const;

  // required .protobuf_unittest.TestAllTypes required_all_types = 1;
  bool has_required_all_types() const;
  void clear_required_all_types();
  static const int kRequiredAllTypesFieldNumber = 1;
  private:
  const ::protobuf_unittest::TestAllTypes& _internal_required_all_types() const;
  public:
  const ::protobuf_unittest::TestAllTypes& required_all_types() const;
  ::protobuf_unittest::TestAllTypes* release_required_all_types();
  ::protobuf_unittest::TestAllTypes* mutable_required_all_types();
  void set_allocated_required_all_types(::protobuf_unittest::TestAllTypes* required_all_types);
  void unsafe_arena_set_allocated_required_all_types(
      ::protobuf_unittest::TestAllTypes* required_all_types);
  ::protobuf_unittest::TestAllTypes* unsafe_arena_release_required_all_types();

  // optional .protobuf_unittest.TestAllTypes optional_all_types = 2;
  bool has_optional_all_types() const;
  void clear_optional_all_types();
  static const int kOptionalAllTypesFieldNumber = 2;
  private:
  const ::protobuf_unittest::TestAllTypes& _internal_optional_all_types() const;
  public:
  const ::protobuf_unittest::TestAllTypes& optional_all_types() const;
  ::protobuf_unittest::TestAllTypes* release_optional_all_types();
  ::protobuf_unittest::TestAllTypes* mutable_optional_all_types();
  void set_allocated_optional_all_types(::protobuf_unittest::TestAllTypes* optional_all_types);
  void unsafe_arena_set_allocated_optional_all_types(
      ::protobuf_unittest::TestAllTypes* optional_all_types);
  ::protobuf_unittest::TestAllTypes* unsafe_arena_release_optional_all_types();

  // optional group OptionalGroup = 10 { ... };
  bool has_optionalgroup() const;
  void clear_optionalgroup();
  static const int kOptionalgroupFieldNumber = 10;
  private:
  const ::protobuf_unittest::TestParsingMerge_OptionalGroup& _internal_optionalgroup() const;
  public:
  const ::protobuf_unittest::TestParsingMerge_OptionalGroup& optionalgroup() const;
  ::protobuf_unittest::TestParsingMerge_OptionalGroup* release_optionalgroup();
  ::protobuf_unittest::TestParsingMerge_OptionalGroup* mutable_optionalgroup();
  void set_allocated_optionalgroup(::protobuf_unittest::TestParsingMerge_OptionalGroup* optionalgroup);
  void unsafe_arena_set_allocated_optionalgroup(
      ::protobuf_unittest::TestParsingMerge_OptionalGroup* optionalgroup);
  ::protobuf_unittest::TestParsingMerge_OptionalGroup* unsafe_arena_release_optionalgroup();

  GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(TestParsingMerge)
  static const int kOptionalExtFieldNumber = 1000;
  static ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestParsingMerge,
      ::google::protobuf::internal::MessageTypeTraits< ::protobuf_unittest::TestAllTypes >, 11, false >
    optional_ext;
  static const int kRepeatedExtFieldNumber = 1001;
  static ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestParsingMerge,
      ::google::protobuf::internal::RepeatedMessageTypeTraits< ::protobuf_unittest::TestAllTypes >, 11, false >
    repeated_ext;
  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestParsingMerge)
 private:
  void set_has_required_all_types();
  void clear_has_required_all_types();
  void set_has_optional_all_types();
  void clear_has_optional_all_types();
  void set_has_optionalgroup();
  void clear_has_optionalgroup();

  ::google::protobuf::internal::ExtensionSet _extensions_;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::TestAllTypes > repeated_all_types_;
  ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::TestParsingMerge_RepeatedGroup > repeatedgroup_;
  ::protobuf_unittest::TestAllTypes* required_all_types_;
  ::protobuf_unittest::TestAllTypes* optional_all_types_;
  ::protobuf_unittest::TestParsingMerge_OptionalGroup* optionalgroup_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class TestCommentInjectionMessage : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.TestCommentInjectionMessage) */ {
 public:
  TestCommentInjectionMessage();
  virtual ~TestCommentInjectionMessage();

  TestCommentInjectionMessage(const TestCommentInjectionMessage& from);

  inline TestCommentInjectionMessage& operator=(const TestCommentInjectionMessage& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TestCommentInjectionMessage(TestCommentInjectionMessage&& from) noexcept
    : TestCommentInjectionMessage() {
    *this = ::std::move(from);
  }

  inline TestCommentInjectionMessage& operator=(TestCommentInjectionMessage&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const TestCommentInjectionMessage& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TestCommentInjectionMessage* internal_default_instance() {
    return reinterpret_cast<const TestCommentInjectionMessage*>(
               &_TestCommentInjectionMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    79;

  void UnsafeArenaSwap(TestCommentInjectionMessage* other);
  void Swap(TestCommentInjectionMessage* other);
  friend void swap(TestCommentInjectionMessage& a, TestCommentInjectionMessage& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline TestCommentInjectionMessage* New() const final {
    return CreateMaybeMessage<TestCommentInjectionMessage>(NULL);
  }

  TestCommentInjectionMessage* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestCommentInjectionMessage>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestCommentInjectionMessage& from);
  void MergeFrom(const TestCommentInjectionMessage& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TestCommentInjectionMessage* other);
  protected:
  explicit TestCommentInjectionMessage(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional string a = 1 [default = "*/ <- Neither should this."];
  bool has_a() const;
  void clear_a();
  static const int kAFieldNumber = 1;
  const ::std::string& a() const;
  void set_a(const ::std::string& value);
  #if LANG_CXX11
  void set_a(::std::string&& value);
  #endif
  void set_a(const char* value);
  void set_a(const char* value, size_t size);
  ::std::string* mutable_a();
  ::std::string* release_a();
  void set_allocated_a(::std::string* a);
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  ::std::string* unsafe_arena_release_a();
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  void unsafe_arena_set_allocated_a(
      ::std::string* a);

  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestCommentInjectionMessage)
 private:
  void set_has_a();
  void clear_has_a();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  public:
  static ::google::protobuf::internal::ExplicitlyConstructed< ::std::string> _i_give_permission_to_break_this_code_default_a_;
  private:
  ::google::protobuf::internal::ArenaStringPtr a_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class FooRequest : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.FooRequest) */ {
 public:
  FooRequest();
  virtual ~FooRequest();

  FooRequest(const FooRequest& from);

  inline FooRequest& operator=(const FooRequest& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  FooRequest(FooRequest&& from) noexcept
    : FooRequest() {
    *this = ::std::move(from);
  }

  inline FooRequest& operator=(FooRequest&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const FooRequest& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const FooRequest* internal_default_instance() {
    return reinterpret_cast<const FooRequest*>(
               &_FooRequest_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    80;

  void UnsafeArenaSwap(FooRequest* other);
  void Swap(FooRequest* other);
  friend void swap(FooRequest& a, FooRequest& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline FooRequest* New() const final {
    return CreateMaybeMessage<FooRequest>(NULL);
  }

  FooRequest* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<FooRequest>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const FooRequest& from);
  void MergeFrom(const FooRequest& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(FooRequest* other);
  protected:
  explicit FooRequest(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // @@protoc_insertion_point(class_scope:protobuf_unittest.FooRequest)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class FooResponse : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.FooResponse) */ {
 public:
  FooResponse();
  virtual ~FooResponse();

  FooResponse(const FooResponse& from);

  inline FooResponse& operator=(const FooResponse& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  FooResponse(FooResponse&& from) noexcept
    : FooResponse() {
    *this = ::std::move(from);
  }

  inline FooResponse& operator=(FooResponse&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const FooResponse& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const FooResponse* internal_default_instance() {
    return reinterpret_cast<const FooResponse*>(
               &_FooResponse_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    81;

  void UnsafeArenaSwap(FooResponse* other);
  void Swap(FooResponse* other);
  friend void swap(FooResponse& a, FooResponse& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline FooResponse* New() const final {
    return CreateMaybeMessage<FooResponse>(NULL);
  }

  FooResponse* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<FooResponse>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const FooResponse& from);
  void MergeFrom(const FooResponse& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(FooResponse* other);
  protected:
  explicit FooResponse(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // @@protoc_insertion_point(class_scope:protobuf_unittest.FooResponse)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class FooClientMessage : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.FooClientMessage) */ {
 public:
  FooClientMessage();
  virtual ~FooClientMessage();

  FooClientMessage(const FooClientMessage& from);

  inline FooClientMessage& operator=(const FooClientMessage& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  FooClientMessage(FooClientMessage&& from) noexcept
    : FooClientMessage() {
    *this = ::std::move(from);
  }

  inline FooClientMessage& operator=(FooClientMessage&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const FooClientMessage& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const FooClientMessage* internal_default_instance() {
    return reinterpret_cast<const FooClientMessage*>(
               &_FooClientMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    82;

  void UnsafeArenaSwap(FooClientMessage* other);
  void Swap(FooClientMessage* other);
  friend void swap(FooClientMessage& a, FooClientMessage& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline FooClientMessage* New() const final {
    return CreateMaybeMessage<FooClientMessage>(NULL);
  }

  FooClientMessage* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<FooClientMessage>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const FooClientMessage& from);
  void MergeFrom(const FooClientMessage& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(FooClientMessage* other);
  protected:
  explicit FooClientMessage(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // @@protoc_insertion_point(class_scope:protobuf_unittest.FooClientMessage)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class FooServerMessage : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.FooServerMessage) */ {
 public:
  FooServerMessage();
  virtual ~FooServerMessage();

  FooServerMessage(const FooServerMessage& from);

  inline FooServerMessage& operator=(const FooServerMessage& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  FooServerMessage(FooServerMessage&& from) noexcept
    : FooServerMessage() {
    *this = ::std::move(from);
  }

  inline FooServerMessage& operator=(FooServerMessage&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const FooServerMessage& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const FooServerMessage* internal_default_instance() {
    return reinterpret_cast<const FooServerMessage*>(
               &_FooServerMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    83;

  void UnsafeArenaSwap(FooServerMessage* other);
  void Swap(FooServerMessage* other);
  friend void swap(FooServerMessage& a, FooServerMessage& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline FooServerMessage* New() const final {
    return CreateMaybeMessage<FooServerMessage>(NULL);
  }

  FooServerMessage* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<FooServerMessage>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const FooServerMessage& from);
  void MergeFrom(const FooServerMessage& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(FooServerMessage* other);
  protected:
  explicit FooServerMessage(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // @@protoc_insertion_point(class_scope:protobuf_unittest.FooServerMessage)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class BarRequest : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.BarRequest) */ {
 public:
  BarRequest();
  virtual ~BarRequest();

  BarRequest(const BarRequest& from);

  inline BarRequest& operator=(const BarRequest& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  BarRequest(BarRequest&& from) noexcept
    : BarRequest() {
    *this = ::std::move(from);
  }

  inline BarRequest& operator=(BarRequest&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const BarRequest& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const BarRequest* internal_default_instance() {
    return reinterpret_cast<const BarRequest*>(
               &_BarRequest_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    84;

  void UnsafeArenaSwap(BarRequest* other);
  void Swap(BarRequest* other);
  friend void swap(BarRequest& a, BarRequest& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline BarRequest* New() const final {
    return CreateMaybeMessage<BarRequest>(NULL);
  }

  BarRequest* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<BarRequest>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const BarRequest& from);
  void MergeFrom(const BarRequest& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(BarRequest* other);
  protected:
  explicit BarRequest(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // @@protoc_insertion_point(class_scope:protobuf_unittest.BarRequest)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class BarResponse : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.BarResponse) */ {
 public:
  BarResponse();
  virtual ~BarResponse();

  BarResponse(const BarResponse& from);

  inline BarResponse& operator=(const BarResponse& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  BarResponse(BarResponse&& from) noexcept
    : BarResponse() {
    *this = ::std::move(from);
  }

  inline BarResponse& operator=(BarResponse&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const BarResponse& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const BarResponse* internal_default_instance() {
    return reinterpret_cast<const BarResponse*>(
               &_BarResponse_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    85;

  void UnsafeArenaSwap(BarResponse* other);
  void Swap(BarResponse* other);
  friend void swap(BarResponse& a, BarResponse& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline BarResponse* New() const final {
    return CreateMaybeMessage<BarResponse>(NULL);
  }

  BarResponse* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<BarResponse>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const BarResponse& from);
  void MergeFrom(const BarResponse& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(BarResponse* other);
  protected:
  explicit BarResponse(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // @@protoc_insertion_point(class_scope:protobuf_unittest.BarResponse)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class TestJsonName : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.TestJsonName) */ {
 public:
  TestJsonName();
  virtual ~TestJsonName();

  TestJsonName(const TestJsonName& from);

  inline TestJsonName& operator=(const TestJsonName& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TestJsonName(TestJsonName&& from) noexcept
    : TestJsonName() {
    *this = ::std::move(from);
  }

  inline TestJsonName& operator=(TestJsonName&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const TestJsonName& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TestJsonName* internal_default_instance() {
    return reinterpret_cast<const TestJsonName*>(
               &_TestJsonName_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    86;

  void UnsafeArenaSwap(TestJsonName* other);
  void Swap(TestJsonName* other);
  friend void swap(TestJsonName& a, TestJsonName& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline TestJsonName* New() const final {
    return CreateMaybeMessage<TestJsonName>(NULL);
  }

  TestJsonName* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestJsonName>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestJsonName& from);
  void MergeFrom(const TestJsonName& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TestJsonName* other);
  protected:
  explicit TestJsonName(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional int32 field_name1 = 1;
  bool has_field_name1() const;
  void clear_field_name1();
  static const int kFieldName1FieldNumber = 1;
  ::google::protobuf::int32 field_name1() const;
  void set_field_name1(::google::protobuf::int32 value);

  // optional int32 fieldName2 = 2;
  bool has_fieldname2() const;
  void clear_fieldname2();
  static const int kFieldName2FieldNumber = 2;
  ::google::protobuf::int32 fieldname2() const;
  void set_fieldname2(::google::protobuf::int32 value);

  // optional int32 FieldName3 = 3;
  bool has_fieldname3() const;
  void clear_fieldname3();
  static const int kFieldName3FieldNumber = 3;
  ::google::protobuf::int32 fieldname3() const;
  void set_fieldname3(::google::protobuf::int32 value);

  // optional int32 _field_name4 = 4;
  bool has__field_name4() const;
  void clear__field_name4();
  static const int kFieldName4FieldNumber = 4;
  ::google::protobuf::int32 _field_name4() const;
  void set__field_name4(::google::protobuf::int32 value);

  // optional int32 FIELD_NAME5 = 5;
  bool has_field_name5() const;
  void clear_field_name5();
  static const int kFIELDNAME5FieldNumber = 5;
  ::google::protobuf::int32 field_name5() const;
  void set_field_name5(::google::protobuf::int32 value);

  // optional int32 field_name6 = 6[json_name = "@type"];
  bool has_field_name6() const;
  void clear_field_name6();
  static const int kFieldName6FieldNumber = 6;
  ::google::protobuf::int32 field_name6() const;
  void set_field_name6(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestJsonName)
 private:
  void set_has_field_name1();
  void clear_has_field_name1();
  void set_has_fieldname2();
  void clear_has_fieldname2();
  void set_has_fieldname3();
  void clear_has_fieldname3();
  void set_has__field_name4();
  void clear_has__field_name4();
  void set_has_field_name5();
  void clear_has_field_name5();
  void set_has_field_name6();
  void clear_has_field_name6();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::int32 field_name1_;
  ::google::protobuf::int32 fieldname2_;
  ::google::protobuf::int32 fieldname3_;
  ::google::protobuf::int32 _field_name4_;
  ::google::protobuf::int32 field_name5_;
  ::google::protobuf::int32 field_name6_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class TestHugeFieldNumbers_OptionalGroup : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.TestHugeFieldNumbers.OptionalGroup) */ {
 public:
  TestHugeFieldNumbers_OptionalGroup();
  virtual ~TestHugeFieldNumbers_OptionalGroup();

  TestHugeFieldNumbers_OptionalGroup(const TestHugeFieldNumbers_OptionalGroup& from);

  inline TestHugeFieldNumbers_OptionalGroup& operator=(const TestHugeFieldNumbers_OptionalGroup& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TestHugeFieldNumbers_OptionalGroup(TestHugeFieldNumbers_OptionalGroup&& from) noexcept
    : TestHugeFieldNumbers_OptionalGroup() {
    *this = ::std::move(from);
  }

  inline TestHugeFieldNumbers_OptionalGroup& operator=(TestHugeFieldNumbers_OptionalGroup&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const TestHugeFieldNumbers_OptionalGroup& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TestHugeFieldNumbers_OptionalGroup* internal_default_instance() {
    return reinterpret_cast<const TestHugeFieldNumbers_OptionalGroup*>(
               &_TestHugeFieldNumbers_OptionalGroup_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    87;

  void UnsafeArenaSwap(TestHugeFieldNumbers_OptionalGroup* other);
  void Swap(TestHugeFieldNumbers_OptionalGroup* other);
  friend void swap(TestHugeFieldNumbers_OptionalGroup& a, TestHugeFieldNumbers_OptionalGroup& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline TestHugeFieldNumbers_OptionalGroup* New() const final {
    return CreateMaybeMessage<TestHugeFieldNumbers_OptionalGroup>(NULL);
  }

  TestHugeFieldNumbers_OptionalGroup* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestHugeFieldNumbers_OptionalGroup>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestHugeFieldNumbers_OptionalGroup& from);
  void MergeFrom(const TestHugeFieldNumbers_OptionalGroup& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TestHugeFieldNumbers_OptionalGroup* other);
  protected:
  explicit TestHugeFieldNumbers_OptionalGroup(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional int32 group_a = 536870009;
  bool has_group_a() const;
  void clear_group_a();
  static const int kGroupAFieldNumber = 536870009;
  ::google::protobuf::int32 group_a() const;
  void set_group_a(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestHugeFieldNumbers.OptionalGroup)
 private:
  void set_has_group_a();
  void clear_has_group_a();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::int32 group_a_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class TestHugeFieldNumbers_StringStringMapEntry_DoNotUse : public ::google::protobuf::internal::MapEntry<TestHugeFieldNumbers_StringStringMapEntry_DoNotUse, 
    ::std::string, ::std::string,
    ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
    ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
    0 > {
public:
  typedef ::google::protobuf::internal::MapEntry<TestHugeFieldNumbers_StringStringMapEntry_DoNotUse, 
    ::std::string, ::std::string,
    ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
    ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
    0 > SuperType;
  TestHugeFieldNumbers_StringStringMapEntry_DoNotUse();
  TestHugeFieldNumbers_StringStringMapEntry_DoNotUse(::google::protobuf::Arena* arena);
  void MergeFrom(const TestHugeFieldNumbers_StringStringMapEntry_DoNotUse& other);
  static const TestHugeFieldNumbers_StringStringMapEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const TestHugeFieldNumbers_StringStringMapEntry_DoNotUse*>(&_TestHugeFieldNumbers_StringStringMapEntry_DoNotUse_default_instance_); }
  void MergeFrom(const ::google::protobuf::Message& other) final;
  ::google::protobuf::Metadata GetMetadata() const;
};

// -------------------------------------------------------------------

class TestHugeFieldNumbers : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.TestHugeFieldNumbers) */ {
 public:
  TestHugeFieldNumbers();
  virtual ~TestHugeFieldNumbers();

  TestHugeFieldNumbers(const TestHugeFieldNumbers& from);

  inline TestHugeFieldNumbers& operator=(const TestHugeFieldNumbers& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TestHugeFieldNumbers(TestHugeFieldNumbers&& from) noexcept
    : TestHugeFieldNumbers() {
    *this = ::std::move(from);
  }

  inline TestHugeFieldNumbers& operator=(TestHugeFieldNumbers&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const TestHugeFieldNumbers& default_instance();

  enum OneofFieldCase {
    kOneofUint32 = 536870011,
    kOneofTestAllTypes = 536870012,
    kOneofString = 536870013,
    kOneofBytes = 536870014,
    ONEOF_FIELD_NOT_SET = 0,
  };

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TestHugeFieldNumbers* internal_default_instance() {
    return reinterpret_cast<const TestHugeFieldNumbers*>(
               &_TestHugeFieldNumbers_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    89;

  void UnsafeArenaSwap(TestHugeFieldNumbers* other);
  void Swap(TestHugeFieldNumbers* other);
  friend void swap(TestHugeFieldNumbers& a, TestHugeFieldNumbers& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline TestHugeFieldNumbers* New() const final {
    return CreateMaybeMessage<TestHugeFieldNumbers>(NULL);
  }

  TestHugeFieldNumbers* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestHugeFieldNumbers>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestHugeFieldNumbers& from);
  void MergeFrom(const TestHugeFieldNumbers& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TestHugeFieldNumbers* other);
  protected:
  explicit TestHugeFieldNumbers(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef TestHugeFieldNumbers_OptionalGroup OptionalGroup;

  // accessors -------------------------------------------------------

  // repeated int32 repeated_int32 = 536870002 [packed = false];
  int repeated_int32_size() const;
  void clear_repeated_int32();
  static const int kRepeatedInt32FieldNumber = 536870002;
  ::google::protobuf::int32 repeated_int32(int index) const;
  void set_repeated_int32(int index, ::google::protobuf::int32 value);
  void add_repeated_int32(::google::protobuf::int32 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
      repeated_int32() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
      mutable_repeated_int32();

  // repeated int32 packed_int32 = 536870003 [packed = true];
  int packed_int32_size() const;
  void clear_packed_int32();
  static const int kPackedInt32FieldNumber = 536870003;
  ::google::protobuf::int32 packed_int32(int index) const;
  void set_packed_int32(int index, ::google::protobuf::int32 value);
  void add_packed_int32(::google::protobuf::int32 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
      packed_int32() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
      mutable_packed_int32();

  // map<string, string> string_string_map = 536870010;
  int string_string_map_size() const;
  void clear_string_string_map();
  static const int kStringStringMapFieldNumber = 536870010;
  const ::google::protobuf::Map< ::std::string, ::std::string >&
      string_string_map() const;
  ::google::protobuf::Map< ::std::string, ::std::string >*
      mutable_string_string_map();

  // optional string optional_string = 536870005;
  bool has_optional_string() const;
  void clear_optional_string();
  static const int kOptionalStringFieldNumber = 536870005;
  const ::std::string& optional_string() const;
  void set_optional_string(const ::std::string& value);
  #if LANG_CXX11
  void set_optional_string(::std::string&& value);
  #endif
  void set_optional_string(const char* value);
  void set_optional_string(const char* value, size_t size);
  ::std::string* mutable_optional_string();
  ::std::string* release_optional_string();
  void set_allocated_optional_string(::std::string* optional_string);
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  ::std::string* unsafe_arena_release_optional_string();
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  void unsafe_arena_set_allocated_optional_string(
      ::std::string* optional_string);

  // optional bytes optional_bytes = 536870006;
  bool has_optional_bytes() const;
  void clear_optional_bytes();
  static const int kOptionalBytesFieldNumber = 536870006;
  const ::std::string& optional_bytes() const;
  void set_optional_bytes(const ::std::string& value);
  #if LANG_CXX11
  void set_optional_bytes(::std::string&& value);
  #endif
  void set_optional_bytes(const char* value);
  void set_optional_bytes(const void* value, size_t size);
  ::std::string* mutable_optional_bytes();
  ::std::string* release_optional_bytes();
  void set_allocated_optional_bytes(::std::string* optional_bytes);
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  ::std::string* unsafe_arena_release_optional_bytes();
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  void unsafe_arena_set_allocated_optional_bytes(
      ::std::string* optional_bytes);

  // optional .protobuf_unittest.ForeignMessage optional_message = 536870007;
  bool has_optional_message() const;
  void clear_optional_message();
  static const int kOptionalMessageFieldNumber = 536870007;
  private:
  const ::protobuf_unittest::ForeignMessage& _internal_optional_message() const;
  public:
  const ::protobuf_unittest::ForeignMessage& optional_message() const;
  ::protobuf_unittest::ForeignMessage* release_optional_message();
  ::protobuf_unittest::ForeignMessage* mutable_optional_message();
  void set_allocated_optional_message(::protobuf_unittest::ForeignMessage* optional_message);
  void unsafe_arena_set_allocated_optional_message(
      ::protobuf_unittest::ForeignMessage* optional_message);
  ::protobuf_unittest::ForeignMessage* unsafe_arena_release_optional_message();

  // optional group OptionalGroup = 536870008 { ... };
  bool has_optionalgroup() const;
  void clear_optionalgroup();
  static const int kOptionalgroupFieldNumber = 536870008;
  private:
  const ::protobuf_unittest::TestHugeFieldNumbers_OptionalGroup& _internal_optionalgroup() const;
  public:
  const ::protobuf_unittest::TestHugeFieldNumbers_OptionalGroup& optionalgroup() const;
  ::protobuf_unittest::TestHugeFieldNumbers_OptionalGroup* release_optionalgroup();
  ::protobuf_unittest::TestHugeFieldNumbers_OptionalGroup* mutable_optionalgroup();
  void set_allocated_optionalgroup(::protobuf_unittest::TestHugeFieldNumbers_OptionalGroup* optionalgroup);
  void unsafe_arena_set_allocated_optionalgroup(
      ::protobuf_unittest::TestHugeFieldNumbers_OptionalGroup* optionalgroup);
  ::protobuf_unittest::TestHugeFieldNumbers_OptionalGroup* unsafe_arena_release_optionalgroup();

  // optional int32 optional_int32 = 536870000;
  bool has_optional_int32() const;
  void clear_optional_int32();
  static const int kOptionalInt32FieldNumber = 536870000;
  ::google::protobuf::int32 optional_int32() const;
  void set_optional_int32(::google::protobuf::int32 value);

  // optional int32 fixed_32 = 536870001;
  bool has_fixed_32() const;
  void clear_fixed_32();
  static const int kFixed32FieldNumber = 536870001;
  ::google::protobuf::int32 fixed_32() const;
  void set_fixed_32(::google::protobuf::int32 value);

  // optional .protobuf_unittest.ForeignEnum optional_enum = 536870004;
  bool has_optional_enum() const;
  void clear_optional_enum();
  static const int kOptionalEnumFieldNumber = 536870004;
  ::protobuf_unittest::ForeignEnum optional_enum() const;
  void set_optional_enum(::protobuf_unittest::ForeignEnum value);

  // optional uint32 oneof_uint32 = 536870011;
  bool has_oneof_uint32() const;
  void clear_oneof_uint32();
  static const int kOneofUint32FieldNumber = 536870011;
  ::google::protobuf::uint32 oneof_uint32() const;
  void set_oneof_uint32(::google::protobuf::uint32 value);

  // optional .protobuf_unittest.TestAllTypes oneof_test_all_types = 536870012;
  bool has_oneof_test_all_types() const;
  void clear_oneof_test_all_types();
  static const int kOneofTestAllTypesFieldNumber = 536870012;
  private:
  const ::protobuf_unittest::TestAllTypes& _internal_oneof_test_all_types() const;
  public:
  const ::protobuf_unittest::TestAllTypes& oneof_test_all_types() const;
  ::protobuf_unittest::TestAllTypes* release_oneof_test_all_types();
  ::protobuf_unittest::TestAllTypes* mutable_oneof_test_all_types();
  void set_allocated_oneof_test_all_types(::protobuf_unittest::TestAllTypes* oneof_test_all_types);
  void unsafe_arena_set_allocated_oneof_test_all_types(
      ::protobuf_unittest::TestAllTypes* oneof_test_all_types);
  ::protobuf_unittest::TestAllTypes* unsafe_arena_release_oneof_test_all_types();

  // optional string oneof_string = 536870013;
  bool has_oneof_string() const;
  void clear_oneof_string();
  static const int kOneofStringFieldNumber = 536870013;
  const ::std::string& oneof_string() const;
  void set_oneof_string(const ::std::string& value);
  #if LANG_CXX11
  void set_oneof_string(::std::string&& value);
  #endif
  void set_oneof_string(const char* value);
  void set_oneof_string(const char* value, size_t size);
  ::std::string* mutable_oneof_string();
  ::std::string* release_oneof_string();
  void set_allocated_oneof_string(::std::string* oneof_string);
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  ::std::string* unsafe_arena_release_oneof_string();
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  void unsafe_arena_set_allocated_oneof_string(
      ::std::string* oneof_string);

  // optional bytes oneof_bytes = 536870014;
  bool has_oneof_bytes() const;
  void clear_oneof_bytes();
  static const int kOneofBytesFieldNumber = 536870014;
  const ::std::string& oneof_bytes() const;
  void set_oneof_bytes(const ::std::string& value);
  #if LANG_CXX11
  void set_oneof_bytes(::std::string&& value);
  #endif
  void set_oneof_bytes(const char* value);
  void set_oneof_bytes(const void* value, size_t size);
  ::std::string* mutable_oneof_bytes();
  ::std::string* release_oneof_bytes();
  void set_allocated_oneof_bytes(::std::string* oneof_bytes);
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  ::std::string* unsafe_arena_release_oneof_bytes();
  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  void unsafe_arena_set_allocated_oneof_bytes(
      ::std::string* oneof_bytes);

  GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(TestHugeFieldNumbers)
  void clear_oneof_field();
  OneofFieldCase oneof_field_case() const;
  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestHugeFieldNumbers)
 private:
  void set_has_optional_int32();
  void clear_has_optional_int32();
  void set_has_fixed_32();
  void clear_has_fixed_32();
  void set_has_optional_enum();
  void clear_has_optional_enum();
  void set_has_optional_string();
  void clear_has_optional_string();
  void set_has_optional_bytes();
  void clear_has_optional_bytes();
  void set_has_optional_message();
  void clear_has_optional_message();
  void set_has_optionalgroup();
  void clear_has_optionalgroup();
  void set_has_oneof_uint32();
  void set_has_oneof_test_all_types();
  void set_has_oneof_string();
  void set_has_oneof_bytes();

  inline bool has_oneof_field() const;
  inline void clear_has_oneof_field();

  ::google::protobuf::internal::ExtensionSet _extensions_;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > repeated_int32_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > packed_int32_;
  mutable int _packed_int32_cached_byte_size_;
  ::google::protobuf::internal::MapField<
      TestHugeFieldNumbers_StringStringMapEntry_DoNotUse,
      ::std::string, ::std::string,
      ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
      ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
      0 > string_string_map_;
  ::google::protobuf::internal::ArenaStringPtr optional_string_;
  ::google::protobuf::internal::ArenaStringPtr optional_bytes_;
  ::protobuf_unittest::ForeignMessage* optional_message_;
  ::protobuf_unittest::TestHugeFieldNumbers_OptionalGroup* optionalgroup_;
  ::google::protobuf::int32 optional_int32_;
  ::google::protobuf::int32 fixed_32_;
  int optional_enum_;
  union OneofFieldUnion {
    OneofFieldUnion() {}
    ::google::protobuf::uint32 oneof_uint32_;
    ::protobuf_unittest::TestAllTypes* oneof_test_all_types_;
    ::google::protobuf::internal::ArenaStringPtr oneof_string_;
    ::google::protobuf::internal::ArenaStringPtr oneof_bytes_;
  } oneof_field_;
  ::google::protobuf::uint32 _oneof_case_[1];

  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class TestExtensionInsideTable : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest.TestExtensionInsideTable) */ {
 public:
  TestExtensionInsideTable();
  virtual ~TestExtensionInsideTable();

  TestExtensionInsideTable(const TestExtensionInsideTable& from);

  inline TestExtensionInsideTable& operator=(const TestExtensionInsideTable& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TestExtensionInsideTable(TestExtensionInsideTable&& from) noexcept
    : TestExtensionInsideTable() {
    *this = ::std::move(from);
  }

  inline TestExtensionInsideTable& operator=(TestExtensionInsideTable&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  inline ::google::protobuf::Arena* GetArena() const final {
    return GetArenaNoVirtual();
  }
  inline void* GetMaybeArenaPointer() const final {
    return MaybeArenaPtr();
  }
  static const ::google::protobuf::Descriptor* descriptor();
  static const TestExtensionInsideTable& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TestExtensionInsideTable* internal_default_instance() {
    return reinterpret_cast<const TestExtensionInsideTable*>(
               &_TestExtensionInsideTable_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    90;

  void UnsafeArenaSwap(TestExtensionInsideTable* other);
  void Swap(TestExtensionInsideTable* other);
  friend void swap(TestExtensionInsideTable& a, TestExtensionInsideTable& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline TestExtensionInsideTable* New() const final {
    return CreateMaybeMessage<TestExtensionInsideTable>(NULL);
  }

  TestExtensionInsideTable* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestExtensionInsideTable>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestExtensionInsideTable& from);
  void MergeFrom(const TestExtensionInsideTable& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TestExtensionInsideTable* other);
  protected:
  explicit TestExtensionInsideTable(::google::protobuf::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional int32 field1 = 1;
  bool has_field1() const;
  void clear_field1();
  static const int kField1FieldNumber = 1;
  ::google::protobuf::int32 field1() const;
  void set_field1(::google::protobuf::int32 value);

  // optional int32 field2 = 2;
  bool has_field2() const;
  void clear_field2();
  static const int kField2FieldNumber = 2;
  ::google::protobuf::int32 field2() const;
  void set_field2(::google::protobuf::int32 value);

  // optional int32 field3 = 3;
  bool has_field3() const;
  void clear_field3();
  static const int kField3FieldNumber = 3;
  ::google::protobuf::int32 field3() const;
  void set_field3(::google::protobuf::int32 value);

  // optional int32 field4 = 4;
  bool has_field4() const;
  void clear_field4();
  static const int kField4FieldNumber = 4;
  ::google::protobuf::int32 field4() const;
  void set_field4(::google::protobuf::int32 value);

  // optional int32 field6 = 6;
  bool has_field6() const;
  void clear_field6();
  static const int kField6FieldNumber = 6;
  ::google::protobuf::int32 field6() const;
  void set_field6(::google::protobuf::int32 value);

  // optional int32 field7 = 7;
  bool has_field7() const;
  void clear_field7();
  static const int kField7FieldNumber = 7;
  ::google::protobuf::int32 field7() const;
  void set_field7(::google::protobuf::int32 value);

  // optional int32 field8 = 8;
  bool has_field8() const;
  void clear_field8();
  static const int kField8FieldNumber = 8;
  ::google::protobuf::int32 field8() const;
  void set_field8(::google::protobuf::int32 value);

  // optional int32 field9 = 9;
  bool has_field9() const;
  void clear_field9();
  static const int kField9FieldNumber = 9;
  ::google::protobuf::int32 field9() const;
  void set_field9(::google::protobuf::int32 value);

  // optional int32 field10 = 10;
  bool has_field10() const;
  void clear_field10();
  static const int kField10FieldNumber = 10;
  ::google::protobuf::int32 field10() const;
  void set_field10(::google::protobuf::int32 value);

  GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(TestExtensionInsideTable)
  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestExtensionInsideTable)
 private:
  void set_has_field1();
  void clear_has_field1();
  void set_has_field2();
  void clear_has_field2();
  void set_has_field3();
  void clear_has_field3();
  void set_has_field4();
  void clear_has_field4();
  void set_has_field6();
  void clear_has_field6();
  void set_has_field7();
  void clear_has_field7();
  void set_has_field8();
  void clear_has_field8();
  void set_has_field9();
  void clear_has_field9();
  void set_has_field10();
  void clear_has_field10();

  ::google::protobuf::internal::ExtensionSet _extensions_;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::int32 field1_;
  ::google::protobuf::int32 field2_;
  ::google::protobuf::int32 field3_;
  ::google::protobuf::int32 field4_;
  ::google::protobuf::int32 field6_;
  ::google::protobuf::int32 field7_;
  ::google::protobuf::int32 field8_;
  ::google::protobuf::int32 field9_;
  ::google::protobuf::int32 field10_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_2eproto::TableStruct;
};
// ===================================================================

class TestService_Stub;

class TestService : public ::google::protobuf::Service {
 protected:
  // This class should be treated as an abstract interface.
  inline TestService() {};
 public:
  virtual ~TestService();

  typedef TestService_Stub Stub;

  static const ::google::protobuf::ServiceDescriptor* descriptor();

  virtual void Foo(::google::protobuf::RpcController* controller,
                       const ::protobuf_unittest::FooRequest* request,
                       ::protobuf_unittest::FooResponse* response,
                       ::google::protobuf::Closure* done);
  virtual void Bar(::google::protobuf::RpcController* controller,
                       const ::protobuf_unittest::BarRequest* request,
                       ::protobuf_unittest::BarResponse* response,
                       ::google::protobuf::Closure* done);

  // implements Service ----------------------------------------------

  const ::google::protobuf::ServiceDescriptor* GetDescriptor();
  void CallMethod(const ::google::protobuf::MethodDescriptor* method,
                  ::google::protobuf::RpcController* controller,
                  const ::google::protobuf::Message* request,
                  ::google::protobuf::Message* response,
                  ::google::protobuf::Closure* done);
  const ::google::protobuf::Message& GetRequestPrototype(
    const ::google::protobuf::MethodDescriptor* method) const;
  const ::google::protobuf::Message& GetResponsePrototype(
    const ::google::protobuf::MethodDescriptor* method) const;

 private:
  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(TestService);
};

class TestService_Stub : public TestService {
 public:
  TestService_Stub(::google::protobuf::RpcChannel* channel);
  TestService_Stub(::google::protobuf::RpcChannel* channel,
                   ::google::protobuf::Service::ChannelOwnership ownership);
  ~TestService_Stub();

  inline ::google::protobuf::RpcChannel* channel() { return channel_; }

  // implements TestService ------------------------------------------

  void Foo(::google::protobuf::RpcController* controller,
                       const ::protobuf_unittest::FooRequest* request,
                       ::protobuf_unittest::FooResponse* response,
                       ::google::protobuf::Closure* done);
  void Bar(::google::protobuf::RpcController* controller,
                       const ::protobuf_unittest::BarRequest* request,
                       ::protobuf_unittest::BarResponse* response,
                       ::google::protobuf::Closure* done);
 private:
  ::google::protobuf::RpcChannel* channel_;
  bool owns_channel_;
  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(TestService_Stub);
};


// ===================================================================

static const int kOptionalInt32ExtensionFieldNumber = 1;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestAllExtensions,
    ::google::protobuf::internal::PrimitiveTypeTraits< ::google::protobuf::int32 >, 5, false >
  optional_int32_extension;
static const int kOptionalInt64ExtensionFieldNumber = 2;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestAllExtensions,
    ::google::protobuf::internal::PrimitiveTypeTraits< ::google::protobuf::int64 >, 3, false >
  optional_int64_extension;
static const int kOptionalUint32ExtensionFieldNumber = 3;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestAllExtensions,
    ::google::protobuf::internal::PrimitiveTypeTraits< ::google::protobuf::uint32 >, 13, false >
  optional_uint32_extension;
static const int kOptionalUint64ExtensionFieldNumber = 4;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestAllExtensions,
    ::google::protobuf::internal::PrimitiveTypeTraits< ::google::protobuf::uint64 >, 4, false >
  optional_uint64_extension;
static const int kOptionalSint32ExtensionFieldNumber = 5;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestAllExtensions,
    ::google::protobuf::internal::PrimitiveTypeTraits< ::google::protobuf::int32 >, 17, false >
  optional_sint32_extension;
static const int kOptionalSint64ExtensionFieldNumber = 6;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestAllExtensions,
    ::google::protobuf::internal::PrimitiveTypeTraits< ::google::protobuf::int64 >, 18, false >
  optional_sint64_extension;
static const int kOptionalFixed32ExtensionFieldNumber = 7;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestAllExtensions,
    ::google::protobuf::internal::PrimitiveTypeTraits< ::google::protobuf::uint32 >, 7, false >
  optional_fixed32_extension;
static const int kOptionalFixed64ExtensionFieldNumber = 8;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestAllExtensions,
    ::google::protobuf::internal::PrimitiveTypeTraits< ::google::protobuf::uint64 >, 6, false >
  optional_fixed64_extension;
static const int kOptionalSfixed32ExtensionFieldNumber = 9;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestAllExtensions,
    ::google::protobuf::internal::PrimitiveTypeTraits< ::google::protobuf::int32 >, 15, false >
  optional_sfixed32_extension;
static const int kOptionalSfixed64ExtensionFieldNumber = 10;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestAllExtensions,
    ::google::protobuf::internal::PrimitiveTypeTraits< ::google::protobuf::int64 >, 16, false >
  optional_sfixed64_extension;
static const int kOptionalFloatExtensionFieldNumber = 11;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestAllExtensions,
    ::google::protobuf::internal::PrimitiveTypeTraits< float >, 2, false >
  optional_float_extension;
static const int kOptionalDoubleExtensionFieldNumber = 12;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestAllExtensions,
    ::google::protobuf::internal::PrimitiveTypeTraits< double >, 1, false >
  optional_double_extension;
static const int kOptionalBoolExtensionFieldNumber = 13;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestAllExtensions,
    ::google::protobuf::internal::PrimitiveTypeTraits< bool >, 8, false >
  optional_bool_extension;
static const int kOptionalStringExtensionFieldNumber = 14;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestAllExtensions,
    ::google::protobuf::internal::StringTypeTraits, 9, false >
  optional_string_extension;
static const int kOptionalBytesExtensionFieldNumber = 15;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestAllExtensions,
    ::google::protobuf::internal::StringTypeTraits, 12, false >
  optional_bytes_extension;
static const int kOptionalgroupExtensionFieldNumber = 16;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestAllExtensions,
    ::google::protobuf::internal::MessageTypeTraits< ::protobuf_unittest::OptionalGroup_extension >, 10, false >
  optionalgroup_extension;
static const int kOptionalNestedMessageExtensionFieldNumber = 18;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestAllExtensions,
    ::google::protobuf::internal::MessageTypeTraits< ::protobuf_unittest::TestAllTypes_NestedMessage >, 11, false >
  optional_nested_message_extension;
static const int kOptionalForeignMessageExtensionFieldNumber = 19;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestAllExtensions,
    ::google::protobuf::internal::MessageTypeTraits< ::protobuf_unittest::ForeignMessage >, 11, false >
  optional_foreign_message_extension;
static const int kOptionalImportMessageExtensionFieldNumber = 20;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestAllExtensions,
    ::google::protobuf::internal::MessageTypeTraits< ::protobuf_unittest_import::ImportMessage >, 11, false >
  optional_import_message_extension;
static const int kOptionalNestedEnumExtensionFieldNumber = 21;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestAllExtensions,
    ::google::protobuf::internal::EnumTypeTraits< ::protobuf_unittest::TestAllTypes_NestedEnum, ::protobuf_unittest::TestAllTypes_NestedEnum_IsValid>, 14, false >
  optional_nested_enum_extension;
static const int kOptionalForeignEnumExtensionFieldNumber = 22;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestAllExtensions,
    ::google::protobuf::internal::EnumTypeTraits< ::protobuf_unittest::ForeignEnum, ::protobuf_unittest::ForeignEnum_IsValid>, 14, false >
  optional_foreign_enum_extension;
static const int kOptionalImportEnumExtensionFieldNumber = 23;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestAllExtensions,
    ::google::protobuf::internal::EnumTypeTraits< ::protobuf_unittest_import::ImportEnum, ::protobuf_unittest_import::ImportEnum_IsValid>, 14, false >
  optional_import_enum_extension;
static const int kOptionalStringPieceExtensionFieldNumber = 24;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestAllExtensions,
    ::google::protobuf::internal::StringTypeTraits, 9, false >
  optional_string_piece_extension;
static const int kOptionalCordExtensionFieldNumber = 25;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestAllExtensions,
    ::google::protobuf::internal::StringTypeTraits, 9, false >
  optional_cord_extension;
static const int kOptionalPublicImportMessageExtensionFieldNumber = 26;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestAllExtensions,
    ::google::protobuf::internal::MessageTypeTraits< ::protobuf_unittest_import::PublicImportMessage >, 11, false >
  optional_public_import_message_extension;
static const int kOptionalLazyMessageExtensionFieldNumber = 27;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestAllExtensions,
    ::google::protobuf::internal::MessageTypeTraits< ::protobuf_unittest::TestAllTypes_NestedMessage >, 11, false >
  optional_lazy_message_extension;
static const int kRepeatedInt32ExtensionFieldNumber = 31;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestAllExtensions,
    ::google::protobuf::internal::RepeatedPrimitiveTypeTraits< ::google::protobuf::int32 >, 5, false >
  repeated_int32_extension;
static const int kRepeatedInt64ExtensionFieldNumber = 32;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestAllExtensions,
    ::google::protobuf::internal::RepeatedPrimitiveTypeTraits< ::google::protobuf::int64 >, 3, false >
  repeated_int64_extension;
static const int kRepeatedUint32ExtensionFieldNumber = 33;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestAllExtensions,
    ::google::protobuf::internal::RepeatedPrimitiveTypeTraits< ::google::protobuf::uint32 >, 13, false >
  repeated_uint32_extension;
static const int kRepeatedUint64ExtensionFieldNumber = 34;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestAllExtensions,
    ::google::protobuf::internal::RepeatedPrimitiveTypeTraits< ::google::protobuf::uint64 >, 4, false >
  repeated_uint64_extension;
static const int kRepeatedSint32ExtensionFieldNumber = 35;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestAllExtensions,
    ::google::protobuf::internal::RepeatedPrimitiveTypeTraits< ::google::protobuf::int32 >, 17, false >
  repeated_sint32_extension;
static const int kRepeatedSint64ExtensionFieldNumber = 36;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestAllExtensions,
    ::google::protobuf::internal::RepeatedPrimitiveTypeTraits< ::google::protobuf::int64 >, 18, false >
  repeated_sint64_extension;
static const int kRepeatedFixed32ExtensionFieldNumber = 37;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestAllExtensions,
    ::google::protobuf::internal::RepeatedPrimitiveTypeTraits< ::google::protobuf::uint32 >, 7, false >
  repeated_fixed32_extension;
static const int kRepeatedFixed64ExtensionFieldNumber = 38;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestAllExtensions,
    ::google::protobuf::internal::RepeatedPrimitiveTypeTraits< ::google::protobuf::uint64 >, 6, false >
  repeated_fixed64_extension;
static const int kRepeatedSfixed32ExtensionFieldNumber = 39;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestAllExtensions,
    ::google::protobuf::internal::RepeatedPrimitiveTypeTraits< ::google::protobuf::int32 >, 15, false >
  repeated_sfixed32_extension;
static const int kRepeatedSfixed64ExtensionFieldNumber = 40;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestAllExtensions,
    ::google::protobuf::internal::RepeatedPrimitiveTypeTraits< ::google::protobuf::int64 >, 16, false >
  repeated_sfixed64_extension;
static const int kRepeatedFloatExtensionFieldNumber = 41;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestAllExtensions,
    ::google::protobuf::internal::RepeatedPrimitiveTypeTraits< float >, 2, false >
  repeated_float_extension;
static const int kRepeatedDoubleExtensionFieldNumber = 42;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestAllExtensions,
    ::google::protobuf::internal::RepeatedPrimitiveTypeTraits< double >, 1, false >
  repeated_double_extension;
static const int kRepeatedBoolExtensionFieldNumber = 43;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestAllExtensions,
    ::google::protobuf::internal::RepeatedPrimitiveTypeTraits< bool >, 8, false >
  repeated_bool_extension;
static const int kRepeatedStringExtensionFieldNumber = 44;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestAllExtensions,
    ::google::protobuf::internal::RepeatedStringTypeTraits, 9, false >
  repeated_string_extension;
static const int kRepeatedBytesExtensionFieldNumber = 45;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestAllExtensions,
    ::google::protobuf::internal::RepeatedStringTypeTraits, 12, false >
  repeated_bytes_extension;
static const int kRepeatedgroupExtensionFieldNumber = 46;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestAllExtensions,
    ::google::protobuf::internal::RepeatedMessageTypeTraits< ::protobuf_unittest::RepeatedGroup_extension >, 10, false >
  repeatedgroup_extension;
static const int kRepeatedNestedMessageExtensionFieldNumber = 48;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestAllExtensions,
    ::google::protobuf::internal::RepeatedMessageTypeTraits< ::protobuf_unittest::TestAllTypes_NestedMessage >, 11, false >
  repeated_nested_message_extension;
static const int kRepeatedForeignMessageExtensionFieldNumber = 49;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestAllExtensions,
    ::google::protobuf::internal::RepeatedMessageTypeTraits< ::protobuf_unittest::ForeignMessage >, 11, false >
  repeated_foreign_message_extension;
static const int kRepeatedImportMessageExtensionFieldNumber = 50;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestAllExtensions,
    ::google::protobuf::internal::RepeatedMessageTypeTraits< ::protobuf_unittest_import::ImportMessage >, 11, false >
  repeated_import_message_extension;
static const int kRepeatedNestedEnumExtensionFieldNumber = 51;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestAllExtensions,
    ::google::protobuf::internal::RepeatedEnumTypeTraits< ::protobuf_unittest::TestAllTypes_NestedEnum, ::protobuf_unittest::TestAllTypes_NestedEnum_IsValid>, 14, false >
  repeated_nested_enum_extension;
static const int kRepeatedForeignEnumExtensionFieldNumber = 52;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestAllExtensions,
    ::google::protobuf::internal::RepeatedEnumTypeTraits< ::protobuf_unittest::ForeignEnum, ::protobuf_unittest::ForeignEnum_IsValid>, 14, false >
  repeated_foreign_enum_extension;
static const int kRepeatedImportEnumExtensionFieldNumber = 53;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestAllExtensions,
    ::google::protobuf::internal::RepeatedEnumTypeTraits< ::protobuf_unittest_import::ImportEnum, ::protobuf_unittest_import::ImportEnum_IsValid>, 14, false >
  repeated_import_enum_extension;
static const int kRepeatedStringPieceExtensionFieldNumber = 54;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestAllExtensions,
    ::google::protobuf::internal::RepeatedStringTypeTraits, 9, false >
  repeated_string_piece_extension;
static const int kRepeatedCordExtensionFieldNumber = 55;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestAllExtensions,
    ::google::protobuf::internal::RepeatedStringTypeTraits, 9, false >
  repeated_cord_extension;
static const int kRepeatedLazyMessageExtensionFieldNumber = 57;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestAllExtensions,
    ::google::protobuf::internal::RepeatedMessageTypeTraits< ::protobuf_unittest::TestAllTypes_NestedMessage >, 11, false >
  repeated_lazy_message_extension;
static const int kDefaultInt32ExtensionFieldNumber = 61;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestAllExtensions,
    ::google::protobuf::internal::PrimitiveTypeTraits< ::google::protobuf::int32 >, 5, false >
  default_int32_extension;
static const int kDefaultInt64ExtensionFieldNumber = 62;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestAllExtensions,
    ::google::protobuf::internal::PrimitiveTypeTraits< ::google::protobuf::int64 >, 3, false >
  default_int64_extension;
static const int kDefaultUint32ExtensionFieldNumber = 63;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestAllExtensions,
    ::google::protobuf::internal::PrimitiveTypeTraits< ::google::protobuf::uint32 >, 13, false >
  default_uint32_extension;
static const int kDefaultUint64ExtensionFieldNumber = 64;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestAllExtensions,
    ::google::protobuf::internal::PrimitiveTypeTraits< ::google::protobuf::uint64 >, 4, false >
  default_uint64_extension;
static const int kDefaultSint32ExtensionFieldNumber = 65;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestAllExtensions,
    ::google::protobuf::internal::PrimitiveTypeTraits< ::google::protobuf::int32 >, 17, false >
  default_sint32_extension;
static const int kDefaultSint64ExtensionFieldNumber = 66;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestAllExtensions,
    ::google::protobuf::internal::PrimitiveTypeTraits< ::google::protobuf::int64 >, 18, false >
  default_sint64_extension;
static const int kDefaultFixed32ExtensionFieldNumber = 67;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestAllExtensions,
    ::google::protobuf::internal::PrimitiveTypeTraits< ::google::protobuf::uint32 >, 7, false >
  default_fixed32_extension;
static const int kDefaultFixed64ExtensionFieldNumber = 68;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestAllExtensions,
    ::google::protobuf::internal::PrimitiveTypeTraits< ::google::protobuf::uint64 >, 6, false >
  default_fixed64_extension;
static const int kDefaultSfixed32ExtensionFieldNumber = 69;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestAllExtensions,
    ::google::protobuf::internal::PrimitiveTypeTraits< ::google::protobuf::int32 >, 15, false >
  default_sfixed32_extension;
static const int kDefaultSfixed64ExtensionFieldNumber = 70;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestAllExtensions,
    ::google::protobuf::internal::PrimitiveTypeTraits< ::google::protobuf::int64 >, 16, false >
  default_sfixed64_extension;
static const int kDefaultFloatExtensionFieldNumber = 71;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestAllExtensions,
    ::google::protobuf::internal::PrimitiveTypeTraits< float >, 2, false >
  default_float_extension;
static const int kDefaultDoubleExtensionFieldNumber = 72;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestAllExtensions,
    ::google::protobuf::internal::PrimitiveTypeTraits< double >, 1, false >
  default_double_extension;
static const int kDefaultBoolExtensionFieldNumber = 73;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestAllExtensions,
    ::google::protobuf::internal::PrimitiveTypeTraits< bool >, 8, false >
  default_bool_extension;
static const int kDefaultStringExtensionFieldNumber = 74;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestAllExtensions,
    ::google::protobuf::internal::StringTypeTraits, 9, false >
  default_string_extension;
static const int kDefaultBytesExtensionFieldNumber = 75;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestAllExtensions,
    ::google::protobuf::internal::StringTypeTraits, 12, false >
  default_bytes_extension;
static const int kDefaultNestedEnumExtensionFieldNumber = 81;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestAllExtensions,
    ::google::protobuf::internal::EnumTypeTraits< ::protobuf_unittest::TestAllTypes_NestedEnum, ::protobuf_unittest::TestAllTypes_NestedEnum_IsValid>, 14, false >
  default_nested_enum_extension;
static const int kDefaultForeignEnumExtensionFieldNumber = 82;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestAllExtensions,
    ::google::protobuf::internal::EnumTypeTraits< ::protobuf_unittest::ForeignEnum, ::protobuf_unittest::ForeignEnum_IsValid>, 14, false >
  default_foreign_enum_extension;
static const int kDefaultImportEnumExtensionFieldNumber = 83;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestAllExtensions,
    ::google::protobuf::internal::EnumTypeTraits< ::protobuf_unittest_import::ImportEnum, ::protobuf_unittest_import::ImportEnum_IsValid>, 14, false >
  default_import_enum_extension;
static const int kDefaultStringPieceExtensionFieldNumber = 84;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestAllExtensions,
    ::google::protobuf::internal::StringTypeTraits, 9, false >
  default_string_piece_extension;
static const int kDefaultCordExtensionFieldNumber = 85;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestAllExtensions,
    ::google::protobuf::internal::StringTypeTraits, 9, false >
  default_cord_extension;
static const int kOneofUint32ExtensionFieldNumber = 111;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestAllExtensions,
    ::google::protobuf::internal::PrimitiveTypeTraits< ::google::protobuf::uint32 >, 13, false >
  oneof_uint32_extension;
static const int kOneofNestedMessageExtensionFieldNumber = 112;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestAllExtensions,
    ::google::protobuf::internal::MessageTypeTraits< ::protobuf_unittest::TestAllTypes_NestedMessage >, 11, false >
  oneof_nested_message_extension;
static const int kOneofStringExtensionFieldNumber = 113;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestAllExtensions,
    ::google::protobuf::internal::StringTypeTraits, 9, false >
  oneof_string_extension;
static const int kOneofBytesExtensionFieldNumber = 114;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestAllExtensions,
    ::google::protobuf::internal::StringTypeTraits, 12, false >
  oneof_bytes_extension;
static const int kMyExtensionStringFieldNumber = 50;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestFieldOrderings,
    ::google::protobuf::internal::StringTypeTraits, 9, false >
  my_extension_string;
static const int kMyExtensionIntFieldNumber = 5;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestFieldOrderings,
    ::google::protobuf::internal::PrimitiveTypeTraits< ::google::protobuf::int32 >, 5, false >
  my_extension_int;
static const int kPackedInt32ExtensionFieldNumber = 90;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestPackedExtensions,
    ::google::protobuf::internal::RepeatedPrimitiveTypeTraits< ::google::protobuf::int32 >, 5, true >
  packed_int32_extension;
static const int kPackedInt64ExtensionFieldNumber = 91;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestPackedExtensions,
    ::google::protobuf::internal::RepeatedPrimitiveTypeTraits< ::google::protobuf::int64 >, 3, true >
  packed_int64_extension;
static const int kPackedUint32ExtensionFieldNumber = 92;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestPackedExtensions,
    ::google::protobuf::internal::RepeatedPrimitiveTypeTraits< ::google::protobuf::uint32 >, 13, true >
  packed_uint32_extension;
static const int kPackedUint64ExtensionFieldNumber = 93;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestPackedExtensions,
    ::google::protobuf::internal::RepeatedPrimitiveTypeTraits< ::google::protobuf::uint64 >, 4, true >
  packed_uint64_extension;
static const int kPackedSint32ExtensionFieldNumber = 94;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestPackedExtensions,
    ::google::protobuf::internal::RepeatedPrimitiveTypeTraits< ::google::protobuf::int32 >, 17, true >
  packed_sint32_extension;
static const int kPackedSint64ExtensionFieldNumber = 95;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestPackedExtensions,
    ::google::protobuf::internal::RepeatedPrimitiveTypeTraits< ::google::protobuf::int64 >, 18, true >
  packed_sint64_extension;
static const int kPackedFixed32ExtensionFieldNumber = 96;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestPackedExtensions,
    ::google::protobuf::internal::RepeatedPrimitiveTypeTraits< ::google::protobuf::uint32 >, 7, true >
  packed_fixed32_extension;
static const int kPackedFixed64ExtensionFieldNumber = 97;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestPackedExtensions,
    ::google::protobuf::internal::RepeatedPrimitiveTypeTraits< ::google::protobuf::uint64 >, 6, true >
  packed_fixed64_extension;
static const int kPackedSfixed32ExtensionFieldNumber = 98;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestPackedExtensions,
    ::google::protobuf::internal::RepeatedPrimitiveTypeTraits< ::google::protobuf::int32 >, 15, true >
  packed_sfixed32_extension;
static const int kPackedSfixed64ExtensionFieldNumber = 99;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestPackedExtensions,
    ::google::protobuf::internal::RepeatedPrimitiveTypeTraits< ::google::protobuf::int64 >, 16, true >
  packed_sfixed64_extension;
static const int kPackedFloatExtensionFieldNumber = 100;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestPackedExtensions,
    ::google::protobuf::internal::RepeatedPrimitiveTypeTraits< float >, 2, true >
  packed_float_extension;
static const int kPackedDoubleExtensionFieldNumber = 101;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestPackedExtensions,
    ::google::protobuf::internal::RepeatedPrimitiveTypeTraits< double >, 1, true >
  packed_double_extension;
static const int kPackedBoolExtensionFieldNumber = 102;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestPackedExtensions,
    ::google::protobuf::internal::RepeatedPrimitiveTypeTraits< bool >, 8, true >
  packed_bool_extension;
static const int kPackedEnumExtensionFieldNumber = 103;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestPackedExtensions,
    ::google::protobuf::internal::RepeatedEnumTypeTraits< ::protobuf_unittest::ForeignEnum, ::protobuf_unittest::ForeignEnum_IsValid>, 14, true >
  packed_enum_extension;
static const int kUnpackedInt32ExtensionFieldNumber = 90;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestUnpackedExtensions,
    ::google::protobuf::internal::RepeatedPrimitiveTypeTraits< ::google::protobuf::int32 >, 5, false >
  unpacked_int32_extension;
static const int kUnpackedInt64ExtensionFieldNumber = 91;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestUnpackedExtensions,
    ::google::protobuf::internal::RepeatedPrimitiveTypeTraits< ::google::protobuf::int64 >, 3, false >
  unpacked_int64_extension;
static const int kUnpackedUint32ExtensionFieldNumber = 92;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestUnpackedExtensions,
    ::google::protobuf::internal::RepeatedPrimitiveTypeTraits< ::google::protobuf::uint32 >, 13, false >
  unpacked_uint32_extension;
static const int kUnpackedUint64ExtensionFieldNumber = 93;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestUnpackedExtensions,
    ::google::protobuf::internal::RepeatedPrimitiveTypeTraits< ::google::protobuf::uint64 >, 4, false >
  unpacked_uint64_extension;
static const int kUnpackedSint32ExtensionFieldNumber = 94;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestUnpackedExtensions,
    ::google::protobuf::internal::RepeatedPrimitiveTypeTraits< ::google::protobuf::int32 >, 17, false >
  unpacked_sint32_extension;
static const int kUnpackedSint64ExtensionFieldNumber = 95;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestUnpackedExtensions,
    ::google::protobuf::internal::RepeatedPrimitiveTypeTraits< ::google::protobuf::int64 >, 18, false >
  unpacked_sint64_extension;
static const int kUnpackedFixed32ExtensionFieldNumber = 96;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestUnpackedExtensions,
    ::google::protobuf::internal::RepeatedPrimitiveTypeTraits< ::google::protobuf::uint32 >, 7, false >
  unpacked_fixed32_extension;
static const int kUnpackedFixed64ExtensionFieldNumber = 97;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestUnpackedExtensions,
    ::google::protobuf::internal::RepeatedPrimitiveTypeTraits< ::google::protobuf::uint64 >, 6, false >
  unpacked_fixed64_extension;
static const int kUnpackedSfixed32ExtensionFieldNumber = 98;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestUnpackedExtensions,
    ::google::protobuf::internal::RepeatedPrimitiveTypeTraits< ::google::protobuf::int32 >, 15, false >
  unpacked_sfixed32_extension;
static const int kUnpackedSfixed64ExtensionFieldNumber = 99;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestUnpackedExtensions,
    ::google::protobuf::internal::RepeatedPrimitiveTypeTraits< ::google::protobuf::int64 >, 16, false >
  unpacked_sfixed64_extension;
static const int kUnpackedFloatExtensionFieldNumber = 100;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestUnpackedExtensions,
    ::google::protobuf::internal::RepeatedPrimitiveTypeTraits< float >, 2, false >
  unpacked_float_extension;
static const int kUnpackedDoubleExtensionFieldNumber = 101;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestUnpackedExtensions,
    ::google::protobuf::internal::RepeatedPrimitiveTypeTraits< double >, 1, false >
  unpacked_double_extension;
static const int kUnpackedBoolExtensionFieldNumber = 102;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestUnpackedExtensions,
    ::google::protobuf::internal::RepeatedPrimitiveTypeTraits< bool >, 8, false >
  unpacked_bool_extension;
static const int kUnpackedEnumExtensionFieldNumber = 103;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestUnpackedExtensions,
    ::google::protobuf::internal::RepeatedEnumTypeTraits< ::protobuf_unittest::ForeignEnum, ::protobuf_unittest::ForeignEnum_IsValid>, 14, false >
  unpacked_enum_extension;
static const int kTestAllTypesFieldNumber = 536860000;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestHugeFieldNumbers,
    ::google::protobuf::internal::MessageTypeTraits< ::protobuf_unittest::TestAllTypes >, 11, false >
  test_all_types;
static const int kTestExtensionInsideTableExtensionFieldNumber = 5;
extern ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestExtensionInsideTable,
    ::google::protobuf::internal::PrimitiveTypeTraits< ::google::protobuf::int32 >, 5, false >
  test_extension_inside_table_extension;

// ===================================================================

#ifdef __GNUC__
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// TestAllTypes_NestedMessage

// optional int32 bb = 1;
inline bool TestAllTypes_NestedMessage::has_bb() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TestAllTypes_NestedMessage::set_has_bb() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TestAllTypes_NestedMessage::clear_has_bb() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TestAllTypes_NestedMessage::clear_bb() {
  bb_ = 0;
  clear_has_bb();
}
inline ::google::protobuf::int32 TestAllTypes_NestedMessage::bb() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestAllTypes.NestedMessage.bb)
  return bb_;
}
inline void TestAllTypes_NestedMessage::set_bb(::google::protobuf::int32 value) {
  set_has_bb();
  bb_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestAllTypes.NestedMessage.bb)
}

// -------------------------------------------------------------------

// TestAllTypes_OptionalGroup

// optional int32 a = 17;
inline bool TestAllTypes_OptionalGroup::has_a() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TestAllTypes_OptionalGroup::set_has_a() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TestAllTypes_OptionalGroup::clear_has_a() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TestAllTypes_OptionalGroup::clear_a() {
  a_ = 0;
  clear_has_a();
}
inline ::google::protobuf::int32 TestAllTypes_OptionalGroup::a() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestAllTypes.OptionalGroup.a)
  return a_;
}
inline void TestAllTypes_OptionalGroup::set_a(::google::protobuf::int32 value) {
  set_has_a();
  a_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestAllTypes.OptionalGroup.a)
}

// -------------------------------------------------------------------

// TestAllTypes_RepeatedGroup

// optional int32 a = 47;
inline bool TestAllTypes_RepeatedGroup::has_a() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TestAllTypes_RepeatedGroup::set_has_a() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TestAllTypes_RepeatedGroup::clear_has_a() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TestAllTypes_RepeatedGroup::clear_a() {
  a_ = 0;
  clear_has_a();
}
inline ::google::protobuf::int32 TestAllTypes_RepeatedGroup::a() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestAllTypes.RepeatedGroup.a)
  return a_;
}
inline void TestAllTypes_RepeatedGroup::set_a(::google::protobuf::int32 value) {
  set_has_a();
  a_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestAllTypes.RepeatedGroup.a)
}

// -------------------------------------------------------------------

// TestAllTypes

// optional int32 optional_int32 = 1;
inline bool TestAllTypes::has_optional_int32() const {
  return (_has_bits_[0] & 0x00008000u) != 0;
}
inline void TestAllTypes::set_has_optional_int32() {
  _has_bits_[0] |= 0x00008000u;
}
inline void TestAllTypes::clear_has_optional_int32() {
  _has_bits_[0] &= ~0x00008000u;
}
inline void TestAllTypes::clear_optional_int32() {
  optional_int32_ = 0;
  clear_has_optional_int32();
}
inline ::google::protobuf::int32 TestAllTypes::optional_int32() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestAllTypes.optional_int32)
  return optional_int32_;
}
inline void TestAllTypes::set_optional_int32(::google::protobuf::int32 value) {
  set_has_optional_int32();
  optional_int32_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestAllTypes.optional_int32)
}

// optional int64 optional_int64 = 2;
inline bool TestAllTypes::has_optional_int64() const {
  return (_has_bits_[0] & 0x00004000u) != 0;
}
inline void TestAllTypes::set_has_optional_int64() {
  _has_bits_[0] |= 0x00004000u;
}
inline void TestAllTypes::clear_has_optional_int64() {
  _has_bits_[0] &= ~0x00004000u;
}
inline void TestAllTypes::clear_optional_int64() {
  optional_int64_ = GOOGLE_LONGLONG(0);
  clear_has_optional_int64();
}
inline ::google::protobuf::int64 TestAllTypes::optional_int64() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestAllTypes.optional_int64)
  return optional_int64_;
}
inline void TestAllTypes::set_optional_int64(::google::protobuf::int64 value) {
  set_has_optional_int64();
  optional_int64_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestAllTypes.optional_int64)
}

// optional uint32 optional_uint32 = 3;
inline bool TestAllTypes::has_optional_uint32() const {
  return (_has_bits_[0] & 0x00010000u) != 0;
}
inline void TestAllTypes::set_has_optional_uint32() {
  _has_bits_[0] |= 0x00010000u;
}
inline void TestAllTypes::clear_has_optional_uint32() {
  _has_bits_[0] &= ~0x00010000u;
}
inline void TestAllTypes::clear_optional_uint32() {
  optional_uint32_ = 0u;
  clear_has_optional_uint32();
}
inline ::google::protobuf::uint32 TestAllTypes::optional_uint32() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestAllTypes.optional_uint32)
  return optional_uint32_;
}
inline void TestAllTypes::set_optional_uint32(::google::protobuf::uint32 value) {
  set_has_optional_uint32();
  optional_uint32_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestAllTypes.optional_uint32)
}

// optional uint64 optional_uint64 = 4;
inline bool TestAllTypes::has_optional_uint64() const {
  return (_has_bits_[0] & 0x00020000u) != 0;
}
inline void TestAllTypes::set_has_optional_uint64() {
  _has_bits_[0] |= 0x00020000u;
}
inline void TestAllTypes::clear_has_optional_uint64() {
  _has_bits_[0] &= ~0x00020000u;
}
inline void TestAllTypes::clear_optional_uint64() {
  optional_uint64_ = GOOGLE_ULONGLONG(0);
  clear_has_optional_uint64();
}
inline ::google::protobuf::uint64 TestAllTypes::optional_uint64() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestAllTypes.optional_uint64)
  return optional_uint64_;
}
inline void TestAllTypes::set_optional_uint64(::google::protobuf::uint64 value) {
  set_has_optional_uint64();
  optional_uint64_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestAllTypes.optional_uint64)
}

// optional sint32 optional_sint32 = 5;
inline bool TestAllTypes::has_optional_sint32() const {
  return (_has_bits_[0] & 0x00080000u) != 0;
}
inline void TestAllTypes::set_has_optional_sint32() {
  _has_bits_[0] |= 0x00080000u;
}
inline void TestAllTypes::clear_has_optional_sint32() {
  _has_bits_[0] &= ~0x00080000u;
}
inline void TestAllTypes::clear_optional_sint32() {
  optional_sint32_ = 0;
  clear_has_optional_sint32();
}
inline ::google::protobuf::int32 TestAllTypes::optional_sint32() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestAllTypes.optional_sint32)
  return optional_sint32_;
}
inline void TestAllTypes::set_optional_sint32(::google::protobuf::int32 value) {
  set_has_optional_sint32();
  optional_sint32_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestAllTypes.optional_sint32)
}

// optional sint64 optional_sint64 = 6;
inline bool TestAllTypes::has_optional_sint64() const {
  return (_has_bits_[0] & 0x00040000u) != 0;
}
inline void TestAllTypes::set_has_optional_sint64() {
  _has_bits_[0] |= 0x00040000u;
}
inline void TestAllTypes::clear_has_optional_sint64() {
  _has_bits_[0] &= ~0x00040000u;
}
inline void TestAllTypes::clear_optional_sint64() {
  optional_sint64_ = GOOGLE_LONGLONG(0);
  clear_has_optional_sint64();
}
inline ::google::protobuf::int64 TestAllTypes::optional_sint64() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestAllTypes.optional_sint64)
  return optional_sint64_;
}
inline void TestAllTypes::set_optional_sint64(::google::protobuf::int64 value) {
  set_has_optional_sint64();
  optional_sint64_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestAllTypes.optional_sint64)
}

// optional fixed32 optional_fixed32 = 7;
inline bool TestAllTypes::has_optional_fixed32() const {
  return (_has_bits_[0] & 0x00100000u) != 0;
}
inline void TestAllTypes::set_has_optional_fixed32() {
  _has_bits_[0] |= 0x00100000u;
}
inline void TestAllTypes::clear_has_optional_fixed32() {
  _has_bits_[0] &= ~0x00100000u;
}
inline void TestAllTypes::clear_optional_fixed32() {
  optional_fixed32_ = 0u;
  clear_has_optional_fixed32();
}
inline ::google::protobuf::uint32 TestAllTypes::optional_fixed32() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestAllTypes.optional_fixed32)
  return optional_fixed32_;
}
inline void TestAllTypes::set_optional_fixed32(::google::protobuf::uint32 value) {
  set_has_optional_fixed32();
  optional_fixed32_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestAllTypes.optional_fixed32)
}

// optional fixed64 optional_fixed64 = 8;
inline bool TestAllTypes::has_optional_fixed64() const {
  return (_has_bits_[0] & 0x00200000u) != 0;
}
inline void TestAllTypes::set_has_optional_fixed64() {
  _has_bits_[0] |= 0x00200000u;
}
inline void TestAllTypes::clear_has_optional_fixed64() {
  _has_bits_[0] &= ~0x00200000u;
}
inline void TestAllTypes::clear_optional_fixed64() {
  optional_fixed64_ = GOOGLE_ULONGLONG(0);
  clear_has_optional_fixed64();
}
inline ::google::protobuf::uint64 TestAllTypes::optional_fixed64() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestAllTypes.optional_fixed64)
  return optional_fixed64_;
}
inline void TestAllTypes::set_optional_fixed64(::google::protobuf::uint64 value) {
  set_has_optional_fixed64();
  optional_fixed64_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestAllTypes.optional_fixed64)
}

// optional sfixed32 optional_sfixed32 = 9;
inline bool TestAllTypes::has_optional_sfixed32() const {
  return (_has_bits_[0] & 0x00800000u) != 0;
}
inline void TestAllTypes::set_has_optional_sfixed32() {
  _has_bits_[0] |= 0x00800000u;
}
inline void TestAllTypes::clear_has_optional_sfixed32() {
  _has_bits_[0] &= ~0x00800000u;
}
inline void TestAllTypes::clear_optional_sfixed32() {
  optional_sfixed32_ = 0;
  clear_has_optional_sfixed32();
}
inline ::google::protobuf::int32 TestAllTypes::optional_sfixed32() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestAllTypes.optional_sfixed32)
  return optional_sfixed32_;
}
inline void TestAllTypes::set_optional_sfixed32(::google::protobuf::int32 value) {
  set_has_optional_sfixed32();
  optional_sfixed32_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestAllTypes.optional_sfixed32)
}

// optional sfixed64 optional_sfixed64 = 10;
inline bool TestAllTypes::has_optional_sfixed64() const {
  return (_has_bits_[0] & 0x00400000u) != 0;
}
inline void TestAllTypes::set_has_optional_sfixed64() {
  _has_bits_[0] |= 0x00400000u;
}
inline void TestAllTypes::clear_has_optional_sfixed64() {
  _has_bits_[0] &= ~0x00400000u;
}
inline void TestAllTypes::clear_optional_sfixed64() {
  optional_sfixed64_ = GOOGLE_LONGLONG(0);
  clear_has_optional_sfixed64();
}
inline ::google::protobuf::int64 TestAllTypes::optional_sfixed64() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestAllTypes.optional_sfixed64)
  return optional_sfixed64_;
}
inline void TestAllTypes::set_optional_sfixed64(::google::protobuf::int64 value) {
  set_has_optional_sfixed64();
  optional_sfixed64_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestAllTypes.optional_sfixed64)
}

// optional float optional_float = 11;
inline bool TestAllTypes::has_optional_float() const {
  return (_has_bits_[0] & 0x01000000u) != 0;
}
inline void TestAllTypes::set_has_optional_float() {
  _has_bits_[0] |= 0x01000000u;
}
inline void TestAllTypes::clear_has_optional_float() {
  _has_bits_[0] &= ~0x01000000u;
}
inline void TestAllTypes::clear_optional_float() {
  optional_float_ = 0;
  clear_has_optional_float();
}
inline float TestAllTypes::optional_float() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestAllTypes.optional_float)
  return optional_float_;
}
inline void TestAllTypes::set_optional_float(float value) {
  set_has_optional_float();
  optional_float_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestAllTypes.optional_float)
}

// optional double optional_double = 12;
inline bool TestAllTypes::has_optional_double() const {
  return (_has_bits_[0] & 0x02000000u) != 0;
}
inline void TestAllTypes::set_has_optional_double() {
  _has_bits_[0] |= 0x02000000u;
}
inline void TestAllTypes::clear_has_optional_double() {
  _has_bits_[0] &= ~0x02000000u;
}
inline void TestAllTypes::clear_optional_double() {
  optional_double_ = 0;
  clear_has_optional_double();
}
inline double TestAllTypes::optional_double() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestAllTypes.optional_double)
  return optional_double_;
}
inline void TestAllTypes::set_optional_double(double value) {
  set_has_optional_double();
  optional_double_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestAllTypes.optional_double)
}

// optional bool optional_bool = 13;
inline bool TestAllTypes::has_optional_bool() const {
  return (_has_bits_[0] & 0x04000000u) != 0;
}
inline void TestAllTypes::set_has_optional_bool() {
  _has_bits_[0] |= 0x04000000u;
}
inline void TestAllTypes::clear_has_optional_bool() {
  _has_bits_[0] &= ~0x04000000u;
}
inline void TestAllTypes::clear_optional_bool() {
  optional_bool_ = false;
  clear_has_optional_bool();
}
inline bool TestAllTypes::optional_bool() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestAllTypes.optional_bool)
  return optional_bool_;
}
inline void TestAllTypes::set_optional_bool(bool value) {
  set_has_optional_bool();
  optional_bool_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestAllTypes.optional_bool)
}

// optional string optional_string = 14;
inline bool TestAllTypes::has_optional_string() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TestAllTypes::set_has_optional_string() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TestAllTypes::clear_has_optional_string() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TestAllTypes::clear_optional_string() {
  optional_string_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
  clear_has_optional_string();
}
inline const ::std::string& TestAllTypes::optional_string() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestAllTypes.optional_string)
  return optional_string_.Get();
}
inline void TestAllTypes::set_optional_string(const ::std::string& value) {
  set_has_optional_string();
  optional_string_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestAllTypes.optional_string)
}
#if LANG_CXX11
inline void TestAllTypes::set_optional_string(::std::string&& value) {
  set_has_optional_string();
  optional_string_.Set(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_rvalue:protobuf_unittest.TestAllTypes.optional_string)
}
#endif
inline void TestAllTypes::set_optional_string(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_optional_string();
  optional_string_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_char:protobuf_unittest.TestAllTypes.optional_string)
}
inline void TestAllTypes::set_optional_string(const char* value,
    size_t size) {
  set_has_optional_string();
  optional_string_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_pointer:protobuf_unittest.TestAllTypes.optional_string)
}
inline ::std::string* TestAllTypes::mutable_optional_string() {
  set_has_optional_string();
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestAllTypes.optional_string)
  return optional_string_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline ::std::string* TestAllTypes::release_optional_string() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestAllTypes.optional_string)
  if (!has_optional_string()) {
    return NULL;
  }
  clear_has_optional_string();
  return optional_string_.ReleaseNonDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline void TestAllTypes::set_allocated_optional_string(::std::string* optional_string) {
  if (optional_string != NULL) {
    set_has_optional_string();
  } else {
    clear_has_optional_string();
  }
  optional_string_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), optional_string,
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestAllTypes.optional_string)
}
inline ::std::string* TestAllTypes::unsafe_arena_release_optional_string() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestAllTypes.optional_string)
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  clear_has_optional_string();
  return optional_string_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      GetArenaNoVirtual());
}
inline void TestAllTypes::unsafe_arena_set_allocated_optional_string(
    ::std::string* optional_string) {
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (optional_string != NULL) {
    set_has_optional_string();
  } else {
    clear_has_optional_string();
  }
  optional_string_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      optional_string, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf_unittest.TestAllTypes.optional_string)
}

// optional bytes optional_bytes = 15;
inline bool TestAllTypes::has_optional_bytes() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void TestAllTypes::set_has_optional_bytes() {
  _has_bits_[0] |= 0x00000002u;
}
inline void TestAllTypes::clear_has_optional_bytes() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void TestAllTypes::clear_optional_bytes() {
  optional_bytes_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
  clear_has_optional_bytes();
}
inline const ::std::string& TestAllTypes::optional_bytes() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestAllTypes.optional_bytes)
  return optional_bytes_.Get();
}
inline void TestAllTypes::set_optional_bytes(const ::std::string& value) {
  set_has_optional_bytes();
  optional_bytes_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestAllTypes.optional_bytes)
}
#if LANG_CXX11
inline void TestAllTypes::set_optional_bytes(::std::string&& value) {
  set_has_optional_bytes();
  optional_bytes_.Set(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_rvalue:protobuf_unittest.TestAllTypes.optional_bytes)
}
#endif
inline void TestAllTypes::set_optional_bytes(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_optional_bytes();
  optional_bytes_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_char:protobuf_unittest.TestAllTypes.optional_bytes)
}
inline void TestAllTypes::set_optional_bytes(const void* value,
    size_t size) {
  set_has_optional_bytes();
  optional_bytes_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_pointer:protobuf_unittest.TestAllTypes.optional_bytes)
}
inline ::std::string* TestAllTypes::mutable_optional_bytes() {
  set_has_optional_bytes();
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestAllTypes.optional_bytes)
  return optional_bytes_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline ::std::string* TestAllTypes::release_optional_bytes() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestAllTypes.optional_bytes)
  if (!has_optional_bytes()) {
    return NULL;
  }
  clear_has_optional_bytes();
  return optional_bytes_.ReleaseNonDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline void TestAllTypes::set_allocated_optional_bytes(::std::string* optional_bytes) {
  if (optional_bytes != NULL) {
    set_has_optional_bytes();
  } else {
    clear_has_optional_bytes();
  }
  optional_bytes_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), optional_bytes,
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestAllTypes.optional_bytes)
}
inline ::std::string* TestAllTypes::unsafe_arena_release_optional_bytes() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestAllTypes.optional_bytes)
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  clear_has_optional_bytes();
  return optional_bytes_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      GetArenaNoVirtual());
}
inline void TestAllTypes::unsafe_arena_set_allocated_optional_bytes(
    ::std::string* optional_bytes) {
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (optional_bytes != NULL) {
    set_has_optional_bytes();
  } else {
    clear_has_optional_bytes();
  }
  optional_bytes_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      optional_bytes, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf_unittest.TestAllTypes.optional_bytes)
}

// optional group OptionalGroup = 16 { ... };
inline bool TestAllTypes::has_optionalgroup() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void TestAllTypes::set_has_optionalgroup() {
  _has_bits_[0] |= 0x00000100u;
}
inline void TestAllTypes::clear_has_optionalgroup() {
  _has_bits_[0] &= ~0x00000100u;
}
inline void TestAllTypes::clear_optionalgroup() {
  if (optionalgroup_ != NULL) optionalgroup_->Clear();
  clear_has_optionalgroup();
}
inline const ::protobuf_unittest::TestAllTypes_OptionalGroup& TestAllTypes::_internal_optionalgroup() const {
  return *optionalgroup_;
}
inline const ::protobuf_unittest::TestAllTypes_OptionalGroup& TestAllTypes::optionalgroup() const {
  const ::protobuf_unittest::TestAllTypes_OptionalGroup* p = optionalgroup_;
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestAllTypes.optionalgroup)
  return p != NULL ? *p : *reinterpret_cast<const ::protobuf_unittest::TestAllTypes_OptionalGroup*>(
      &::protobuf_unittest::_TestAllTypes_OptionalGroup_default_instance_);
}
inline ::protobuf_unittest::TestAllTypes_OptionalGroup* TestAllTypes::release_optionalgroup() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestAllTypes.optionalgroup)
  clear_has_optionalgroup();
  ::protobuf_unittest::TestAllTypes_OptionalGroup* temp = optionalgroup_;
  if (GetArenaNoVirtual() != NULL) {
    temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
  }
  optionalgroup_ = NULL;
  return temp;
}
inline ::protobuf_unittest::TestAllTypes_OptionalGroup* TestAllTypes::unsafe_arena_release_optionalgroup() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestAllTypes.optionalgroup)
  clear_has_optionalgroup();
  ::protobuf_unittest::TestAllTypes_OptionalGroup* temp = optionalgroup_;
  optionalgroup_ = NULL;
  return temp;
}
inline ::protobuf_unittest::TestAllTypes_OptionalGroup* TestAllTypes::mutable_optionalgroup() {
  set_has_optionalgroup();
  if (optionalgroup_ == NULL) {
    auto* p = CreateMaybeMessage<::protobuf_unittest::TestAllTypes_OptionalGroup>(GetArenaNoVirtual());
    optionalgroup_ = p;
  }
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestAllTypes.optionalgroup)
  return optionalgroup_;
}
inline void TestAllTypes::set_allocated_optionalgroup(::protobuf_unittest::TestAllTypes_OptionalGroup* optionalgroup) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete optionalgroup_;
  }
  if (optionalgroup) {
    ::google::protobuf::Arena* submessage_arena =
      ::google::protobuf::Arena::GetArena(optionalgroup);
    if (message_arena != submessage_arena) {
      optionalgroup = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, optionalgroup, submessage_arena);
    }
    set_has_optionalgroup();
  } else {
    clear_has_optionalgroup();
  }
  optionalgroup_ = optionalgroup;
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestAllTypes.optionalgroup)
}

// optional .protobuf_unittest.TestAllTypes.NestedMessage optional_nested_message = 18;
inline bool TestAllTypes::has_optional_nested_message() const {
  return (_has_bits_[0] & 0x00000200u) != 0;
}
inline void TestAllTypes::set_has_optional_nested_message() {
  _has_bits_[0] |= 0x00000200u;
}
inline void TestAllTypes::clear_has_optional_nested_message() {
  _has_bits_[0] &= ~0x00000200u;
}
inline void TestAllTypes::clear_optional_nested_message() {
  if (optional_nested_message_ != NULL) optional_nested_message_->Clear();
  clear_has_optional_nested_message();
}
inline const ::protobuf_unittest::TestAllTypes_NestedMessage& TestAllTypes::_internal_optional_nested_message() const {
  return *optional_nested_message_;
}
inline const ::protobuf_unittest::TestAllTypes_NestedMessage& TestAllTypes::optional_nested_message() const {
  const ::protobuf_unittest::TestAllTypes_NestedMessage* p = optional_nested_message_;
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestAllTypes.optional_nested_message)
  return p != NULL ? *p : *reinterpret_cast<const ::protobuf_unittest::TestAllTypes_NestedMessage*>(
      &::protobuf_unittest::_TestAllTypes_NestedMessage_default_instance_);
}
inline ::protobuf_unittest::TestAllTypes_NestedMessage* TestAllTypes::release_optional_nested_message() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestAllTypes.optional_nested_message)
  clear_has_optional_nested_message();
  ::protobuf_unittest::TestAllTypes_NestedMessage* temp = optional_nested_message_;
  if (GetArenaNoVirtual() != NULL) {
    temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
  }
  optional_nested_message_ = NULL;
  return temp;
}
inline ::protobuf_unittest::TestAllTypes_NestedMessage* TestAllTypes::unsafe_arena_release_optional_nested_message() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestAllTypes.optional_nested_message)
  clear_has_optional_nested_message();
  ::protobuf_unittest::TestAllTypes_NestedMessage* temp = optional_nested_message_;
  optional_nested_message_ = NULL;
  return temp;
}
inline ::protobuf_unittest::TestAllTypes_NestedMessage* TestAllTypes::mutable_optional_nested_message() {
  set_has_optional_nested_message();
  if (optional_nested_message_ == NULL) {
    auto* p = CreateMaybeMessage<::protobuf_unittest::TestAllTypes_NestedMessage>(GetArenaNoVirtual());
    optional_nested_message_ = p;
  }
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestAllTypes.optional_nested_message)
  return optional_nested_message_;
}
inline void TestAllTypes::set_allocated_optional_nested_message(::protobuf_unittest::TestAllTypes_NestedMessage* optional_nested_message) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete optional_nested_message_;
  }
  if (optional_nested_message) {
    ::google::protobuf::Arena* submessage_arena =
      ::google::protobuf::Arena::GetArena(optional_nested_message);
    if (message_arena != submessage_arena) {
      optional_nested_message = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, optional_nested_message, submessage_arena);
    }
    set_has_optional_nested_message();
  } else {
    clear_has_optional_nested_message();
  }
  optional_nested_message_ = optional_nested_message;
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestAllTypes.optional_nested_message)
}

// optional .protobuf_unittest.ForeignMessage optional_foreign_message = 19;
inline bool TestAllTypes::has_optional_foreign_message() const {
  return (_has_bits_[0] & 0x00000400u) != 0;
}
inline void TestAllTypes::set_has_optional_foreign_message() {
  _has_bits_[0] |= 0x00000400u;
}
inline void TestAllTypes::clear_has_optional_foreign_message() {
  _has_bits_[0] &= ~0x00000400u;
}
inline void TestAllTypes::clear_optional_foreign_message() {
  if (optional_foreign_message_ != NULL) optional_foreign_message_->Clear();
  clear_has_optional_foreign_message();
}
inline const ::protobuf_unittest::ForeignMessage& TestAllTypes::_internal_optional_foreign_message() const {
  return *optional_foreign_message_;
}
inline const ::protobuf_unittest::ForeignMessage& TestAllTypes::optional_foreign_message() const {
  const ::protobuf_unittest::ForeignMessage* p = optional_foreign_message_;
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestAllTypes.optional_foreign_message)
  return p != NULL ? *p : *reinterpret_cast<const ::protobuf_unittest::ForeignMessage*>(
      &::protobuf_unittest::_ForeignMessage_default_instance_);
}
inline ::protobuf_unittest::ForeignMessage* TestAllTypes::release_optional_foreign_message() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestAllTypes.optional_foreign_message)
  clear_has_optional_foreign_message();
  ::protobuf_unittest::ForeignMessage* temp = optional_foreign_message_;
  if (GetArenaNoVirtual() != NULL) {
    temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
  }
  optional_foreign_message_ = NULL;
  return temp;
}
inline ::protobuf_unittest::ForeignMessage* TestAllTypes::unsafe_arena_release_optional_foreign_message() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestAllTypes.optional_foreign_message)
  clear_has_optional_foreign_message();
  ::protobuf_unittest::ForeignMessage* temp = optional_foreign_message_;
  optional_foreign_message_ = NULL;
  return temp;
}
inline ::protobuf_unittest::ForeignMessage* TestAllTypes::mutable_optional_foreign_message() {
  set_has_optional_foreign_message();
  if (optional_foreign_message_ == NULL) {
    auto* p = CreateMaybeMessage<::protobuf_unittest::ForeignMessage>(GetArenaNoVirtual());
    optional_foreign_message_ = p;
  }
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestAllTypes.optional_foreign_message)
  return optional_foreign_message_;
}
inline void TestAllTypes::set_allocated_optional_foreign_message(::protobuf_unittest::ForeignMessage* optional_foreign_message) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete optional_foreign_message_;
  }
  if (optional_foreign_message) {
    ::google::protobuf::Arena* submessage_arena =
      ::google::protobuf::Arena::GetArena(optional_foreign_message);
    if (message_arena != submessage_arena) {
      optional_foreign_message = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, optional_foreign_message, submessage_arena);
    }
    set_has_optional_foreign_message();
  } else {
    clear_has_optional_foreign_message();
  }
  optional_foreign_message_ = optional_foreign_message;
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestAllTypes.optional_foreign_message)
}

// optional .protobuf_unittest_import.ImportMessage optional_import_message = 20;
inline bool TestAllTypes::has_optional_import_message() const {
  return (_has_bits_[0] & 0x00000800u) != 0;
}
inline void TestAllTypes::set_has_optional_import_message() {
  _has_bits_[0] |= 0x00000800u;
}
inline void TestAllTypes::clear_has_optional_import_message() {
  _has_bits_[0] &= ~0x00000800u;
}
inline const ::protobuf_unittest_import::ImportMessage& TestAllTypes::_internal_optional_import_message() const {
  return *optional_import_message_;
}
inline const ::protobuf_unittest_import::ImportMessage& TestAllTypes::optional_import_message() const {
  const ::protobuf_unittest_import::ImportMessage* p = optional_import_message_;
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestAllTypes.optional_import_message)
  return p != NULL ? *p : *reinterpret_cast<const ::protobuf_unittest_import::ImportMessage*>(
      &::protobuf_unittest_import::_ImportMessage_default_instance_);
}
inline ::protobuf_unittest_import::ImportMessage* TestAllTypes::release_optional_import_message() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestAllTypes.optional_import_message)
  clear_has_optional_import_message();
  ::protobuf_unittest_import::ImportMessage* temp = optional_import_message_;
  if (GetArenaNoVirtual() != NULL) {
    temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
  }
  optional_import_message_ = NULL;
  return temp;
}
inline ::protobuf_unittest_import::ImportMessage* TestAllTypes::unsafe_arena_release_optional_import_message() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestAllTypes.optional_import_message)
  clear_has_optional_import_message();
  ::protobuf_unittest_import::ImportMessage* temp = optional_import_message_;
  optional_import_message_ = NULL;
  return temp;
}
inline ::protobuf_unittest_import::ImportMessage* TestAllTypes::mutable_optional_import_message() {
  set_has_optional_import_message();
  if (optional_import_message_ == NULL) {
    auto* p = CreateMaybeMessage<::protobuf_unittest_import::ImportMessage>(GetArenaNoVirtual());
    optional_import_message_ = p;
  }
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestAllTypes.optional_import_message)
  return optional_import_message_;
}
inline void TestAllTypes::set_allocated_optional_import_message(::protobuf_unittest_import::ImportMessage* optional_import_message) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete reinterpret_cast< ::google::protobuf::MessageLite*>(optional_import_message_);
  }
  if (optional_import_message) {
    ::google::protobuf::Arena* submessage_arena =
      reinterpret_cast<::google::protobuf::MessageLite*>(optional_import_message)->GetArena();
    if (message_arena != submessage_arena) {
      optional_import_message = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, optional_import_message, submessage_arena);
    }
    set_has_optional_import_message();
  } else {
    clear_has_optional_import_message();
  }
  optional_import_message_ = optional_import_message;
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestAllTypes.optional_import_message)
}

// optional .protobuf_unittest.TestAllTypes.NestedEnum optional_nested_enum = 21;
inline bool TestAllTypes::has_optional_nested_enum() const {
  return (_has_bits_[0] & 0x10000000u) != 0;
}
inline void TestAllTypes::set_has_optional_nested_enum() {
  _has_bits_[0] |= 0x10000000u;
}
inline void TestAllTypes::clear_has_optional_nested_enum() {
  _has_bits_[0] &= ~0x10000000u;
}
inline void TestAllTypes::clear_optional_nested_enum() {
  optional_nested_enum_ = 1;
  clear_has_optional_nested_enum();
}
inline ::protobuf_unittest::TestAllTypes_NestedEnum TestAllTypes::optional_nested_enum() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestAllTypes.optional_nested_enum)
  return static_cast< ::protobuf_unittest::TestAllTypes_NestedEnum >(optional_nested_enum_);
}
inline void TestAllTypes::set_optional_nested_enum(::protobuf_unittest::TestAllTypes_NestedEnum value) {
  assert(::protobuf_unittest::TestAllTypes_NestedEnum_IsValid(value));
  set_has_optional_nested_enum();
  optional_nested_enum_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestAllTypes.optional_nested_enum)
}

// optional .protobuf_unittest.ForeignEnum optional_foreign_enum = 22;
inline bool TestAllTypes::has_optional_foreign_enum() const {
  return (_has_bits_[0] & 0x20000000u) != 0;
}
inline void TestAllTypes::set_has_optional_foreign_enum() {
  _has_bits_[0] |= 0x20000000u;
}
inline void TestAllTypes::clear_has_optional_foreign_enum() {
  _has_bits_[0] &= ~0x20000000u;
}
inline void TestAllTypes::clear_optional_foreign_enum() {
  optional_foreign_enum_ = 4;
  clear_has_optional_foreign_enum();
}
inline ::protobuf_unittest::ForeignEnum TestAllTypes::optional_foreign_enum() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestAllTypes.optional_foreign_enum)
  return static_cast< ::protobuf_unittest::ForeignEnum >(optional_foreign_enum_);
}
inline void TestAllTypes::set_optional_foreign_enum(::protobuf_unittest::ForeignEnum value) {
  assert(::protobuf_unittest::ForeignEnum_IsValid(value));
  set_has_optional_foreign_enum();
  optional_foreign_enum_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestAllTypes.optional_foreign_enum)
}

// optional .protobuf_unittest_import.ImportEnum optional_import_enum = 23;
inline bool TestAllTypes::has_optional_import_enum() const {
  return (_has_bits_[0] & 0x40000000u) != 0;
}
inline void TestAllTypes::set_has_optional_import_enum() {
  _has_bits_[0] |= 0x40000000u;
}
inline void TestAllTypes::clear_has_optional_import_enum() {
  _has_bits_[0] &= ~0x40000000u;
}
inline void TestAllTypes::clear_optional_import_enum() {
  optional_import_enum_ = 7;
  clear_has_optional_import_enum();
}
inline ::protobuf_unittest_import::ImportEnum TestAllTypes::optional_import_enum() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestAllTypes.optional_import_enum)
  return static_cast< ::protobuf_unittest_import::ImportEnum >(optional_import_enum_);
}
inline void TestAllTypes::set_optional_import_enum(::protobuf_unittest_import::ImportEnum value) {
  assert(::protobuf_unittest_import::ImportEnum_IsValid(value));
  set_has_optional_import_enum();
  optional_import_enum_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestAllTypes.optional_import_enum)
}

// optional string optional_string_piece = 24 [ctype = STRING_PIECE];
inline bool TestAllTypes::has_optional_string_piece() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void TestAllTypes::set_has_optional_string_piece() {
  _has_bits_[0] |= 0x00000004u;
}
inline void TestAllTypes::clear_has_optional_string_piece() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void TestAllTypes::clear_optional_string_piece() {
  optional_string_piece_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
  clear_has_optional_string_piece();
}
inline const ::std::string& TestAllTypes::optional_string_piece() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestAllTypes.optional_string_piece)
  return optional_string_piece_.Get();
}
inline void TestAllTypes::set_optional_string_piece(const ::std::string& value) {
  set_has_optional_string_piece();
  optional_string_piece_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestAllTypes.optional_string_piece)
}
#if LANG_CXX11
inline void TestAllTypes::set_optional_string_piece(::std::string&& value) {
  set_has_optional_string_piece();
  optional_string_piece_.Set(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_rvalue:protobuf_unittest.TestAllTypes.optional_string_piece)
}
#endif
inline void TestAllTypes::set_optional_string_piece(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_optional_string_piece();
  optional_string_piece_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_char:protobuf_unittest.TestAllTypes.optional_string_piece)
}
inline void TestAllTypes::set_optional_string_piece(const char* value,
    size_t size) {
  set_has_optional_string_piece();
  optional_string_piece_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_pointer:protobuf_unittest.TestAllTypes.optional_string_piece)
}
inline ::std::string* TestAllTypes::mutable_optional_string_piece() {
  set_has_optional_string_piece();
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestAllTypes.optional_string_piece)
  return optional_string_piece_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline ::std::string* TestAllTypes::release_optional_string_piece() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestAllTypes.optional_string_piece)
  if (!has_optional_string_piece()) {
    return NULL;
  }
  clear_has_optional_string_piece();
  return optional_string_piece_.ReleaseNonDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline void TestAllTypes::set_allocated_optional_string_piece(::std::string* optional_string_piece) {
  if (optional_string_piece != NULL) {
    set_has_optional_string_piece();
  } else {
    clear_has_optional_string_piece();
  }
  optional_string_piece_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), optional_string_piece,
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestAllTypes.optional_string_piece)
}
inline ::std::string* TestAllTypes::unsafe_arena_release_optional_string_piece() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestAllTypes.optional_string_piece)
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  clear_has_optional_string_piece();
  return optional_string_piece_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      GetArenaNoVirtual());
}
inline void TestAllTypes::unsafe_arena_set_allocated_optional_string_piece(
    ::std::string* optional_string_piece) {
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (optional_string_piece != NULL) {
    set_has_optional_string_piece();
  } else {
    clear_has_optional_string_piece();
  }
  optional_string_piece_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      optional_string_piece, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf_unittest.TestAllTypes.optional_string_piece)
}

// optional string optional_cord = 25 [ctype = CORD];
inline bool TestAllTypes::has_optional_cord() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void TestAllTypes::set_has_optional_cord() {
  _has_bits_[0] |= 0x00000008u;
}
inline void TestAllTypes::clear_has_optional_cord() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void TestAllTypes::clear_optional_cord() {
  optional_cord_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
  clear_has_optional_cord();
}
inline const ::std::string& TestAllTypes::optional_cord() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestAllTypes.optional_cord)
  return optional_cord_.Get();
}
inline void TestAllTypes::set_optional_cord(const ::std::string& value) {
  set_has_optional_cord();
  optional_cord_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestAllTypes.optional_cord)
}
#if LANG_CXX11
inline void TestAllTypes::set_optional_cord(::std::string&& value) {
  set_has_optional_cord();
  optional_cord_.Set(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_rvalue:protobuf_unittest.TestAllTypes.optional_cord)
}
#endif
inline void TestAllTypes::set_optional_cord(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_optional_cord();
  optional_cord_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_char:protobuf_unittest.TestAllTypes.optional_cord)
}
inline void TestAllTypes::set_optional_cord(const char* value,
    size_t size) {
  set_has_optional_cord();
  optional_cord_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_pointer:protobuf_unittest.TestAllTypes.optional_cord)
}
inline ::std::string* TestAllTypes::mutable_optional_cord() {
  set_has_optional_cord();
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestAllTypes.optional_cord)
  return optional_cord_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline ::std::string* TestAllTypes::release_optional_cord() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestAllTypes.optional_cord)
  if (!has_optional_cord()) {
    return NULL;
  }
  clear_has_optional_cord();
  return optional_cord_.ReleaseNonDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline void TestAllTypes::set_allocated_optional_cord(::std::string* optional_cord) {
  if (optional_cord != NULL) {
    set_has_optional_cord();
  } else {
    clear_has_optional_cord();
  }
  optional_cord_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), optional_cord,
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestAllTypes.optional_cord)
}
inline ::std::string* TestAllTypes::unsafe_arena_release_optional_cord() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestAllTypes.optional_cord)
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  clear_has_optional_cord();
  return optional_cord_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      GetArenaNoVirtual());
}
inline void TestAllTypes::unsafe_arena_set_allocated_optional_cord(
    ::std::string* optional_cord) {
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (optional_cord != NULL) {
    set_has_optional_cord();
  } else {
    clear_has_optional_cord();
  }
  optional_cord_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      optional_cord, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf_unittest.TestAllTypes.optional_cord)
}

// optional .protobuf_unittest_import.PublicImportMessage optional_public_import_message = 26;
inline bool TestAllTypes::has_optional_public_import_message() const {
  return (_has_bits_[0] & 0x00001000u) != 0;
}
inline void TestAllTypes::set_has_optional_public_import_message() {
  _has_bits_[0] |= 0x00001000u;
}
inline void TestAllTypes::clear_has_optional_public_import_message() {
  _has_bits_[0] &= ~0x00001000u;
}
inline const ::protobuf_unittest_import::PublicImportMessage& TestAllTypes::_internal_optional_public_import_message() const {
  return *optional_public_import_message_;
}
inline const ::protobuf_unittest_import::PublicImportMessage& TestAllTypes::optional_public_import_message() const {
  const ::protobuf_unittest_import::PublicImportMessage* p = optional_public_import_message_;
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestAllTypes.optional_public_import_message)
  return p != NULL ? *p : *reinterpret_cast<const ::protobuf_unittest_import::PublicImportMessage*>(
      &::protobuf_unittest_import::_PublicImportMessage_default_instance_);
}
inline ::protobuf_unittest_import::PublicImportMessage* TestAllTypes::release_optional_public_import_message() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestAllTypes.optional_public_import_message)
  clear_has_optional_public_import_message();
  ::protobuf_unittest_import::PublicImportMessage* temp = optional_public_import_message_;
  if (GetArenaNoVirtual() != NULL) {
    temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
  }
  optional_public_import_message_ = NULL;
  return temp;
}
inline ::protobuf_unittest_import::PublicImportMessage* TestAllTypes::unsafe_arena_release_optional_public_import_message() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestAllTypes.optional_public_import_message)
  clear_has_optional_public_import_message();
  ::protobuf_unittest_import::PublicImportMessage* temp = optional_public_import_message_;
  optional_public_import_message_ = NULL;
  return temp;
}
inline ::protobuf_unittest_import::PublicImportMessage* TestAllTypes::mutable_optional_public_import_message() {
  set_has_optional_public_import_message();
  if (optional_public_import_message_ == NULL) {
    auto* p = CreateMaybeMessage<::protobuf_unittest_import::PublicImportMessage>(GetArenaNoVirtual());
    optional_public_import_message_ = p;
  }
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestAllTypes.optional_public_import_message)
  return optional_public_import_message_;
}
inline void TestAllTypes::set_allocated_optional_public_import_message(::protobuf_unittest_import::PublicImportMessage* optional_public_import_message) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete reinterpret_cast< ::google::protobuf::MessageLite*>(optional_public_import_message_);
  }
  if (optional_public_import_message) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      optional_public_import_message = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, optional_public_import_message, submessage_arena);
    }
    set_has_optional_public_import_message();
  } else {
    clear_has_optional_public_import_message();
  }
  optional_public_import_message_ = optional_public_import_message;
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestAllTypes.optional_public_import_message)
}

// optional .protobuf_unittest.TestAllTypes.NestedMessage optional_lazy_message = 27 [lazy = true];
inline bool TestAllTypes::has_optional_lazy_message() const {
  return (_has_bits_[0] & 0x00002000u) != 0;
}
inline void TestAllTypes::set_has_optional_lazy_message() {
  _has_bits_[0] |= 0x00002000u;
}
inline void TestAllTypes::clear_has_optional_lazy_message() {
  _has_bits_[0] &= ~0x00002000u;
}
inline void TestAllTypes::clear_optional_lazy_message() {
  if (optional_lazy_message_ != NULL) optional_lazy_message_->Clear();
  clear_has_optional_lazy_message();
}
inline const ::protobuf_unittest::TestAllTypes_NestedMessage& TestAllTypes::_internal_optional_lazy_message() const {
  return *optional_lazy_message_;
}
inline const ::protobuf_unittest::TestAllTypes_NestedMessage& TestAllTypes::optional_lazy_message() const {
  const ::protobuf_unittest::TestAllTypes_NestedMessage* p = optional_lazy_message_;
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestAllTypes.optional_lazy_message)
  return p != NULL ? *p : *reinterpret_cast<const ::protobuf_unittest::TestAllTypes_NestedMessage*>(
      &::protobuf_unittest::_TestAllTypes_NestedMessage_default_instance_);
}
inline ::protobuf_unittest::TestAllTypes_NestedMessage* TestAllTypes::release_optional_lazy_message() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestAllTypes.optional_lazy_message)
  clear_has_optional_lazy_message();
  ::protobuf_unittest::TestAllTypes_NestedMessage* temp = optional_lazy_message_;
  if (GetArenaNoVirtual() != NULL) {
    temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
  }
  optional_lazy_message_ = NULL;
  return temp;
}
inline ::protobuf_unittest::TestAllTypes_NestedMessage* TestAllTypes::unsafe_arena_release_optional_lazy_message() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestAllTypes.optional_lazy_message)
  clear_has_optional_lazy_message();
  ::protobuf_unittest::TestAllTypes_NestedMessage* temp = optional_lazy_message_;
  optional_lazy_message_ = NULL;
  return temp;
}
inline ::protobuf_unittest::TestAllTypes_NestedMessage* TestAllTypes::mutable_optional_lazy_message() {
  set_has_optional_lazy_message();
  if (optional_lazy_message_ == NULL) {
    auto* p = CreateMaybeMessage<::protobuf_unittest::TestAllTypes_NestedMessage>(GetArenaNoVirtual());
    optional_lazy_message_ = p;
  }
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestAllTypes.optional_lazy_message)
  return optional_lazy_message_;
}
inline void TestAllTypes::set_allocated_optional_lazy_message(::protobuf_unittest::TestAllTypes_NestedMessage* optional_lazy_message) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete optional_lazy_message_;
  }
  if (optional_lazy_message) {
    ::google::protobuf::Arena* submessage_arena =
      ::google::protobuf::Arena::GetArena(optional_lazy_message);
    if (message_arena != submessage_arena) {
      optional_lazy_message = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, optional_lazy_message, submessage_arena);
    }
    set_has_optional_lazy_message();
  } else {
    clear_has_optional_lazy_message();
  }
  optional_lazy_message_ = optional_lazy_message;
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestAllTypes.optional_lazy_message)
}

// repeated int32 repeated_int32 = 31;
inline int TestAllTypes::repeated_int32_size() const {
  return repeated_int32_.size();
}
inline void TestAllTypes::clear_repeated_int32() {
  repeated_int32_.Clear();
}
inline ::google::protobuf::int32 TestAllTypes::repeated_int32(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestAllTypes.repeated_int32)
  return repeated_int32_.Get(index);
}
inline void TestAllTypes::set_repeated_int32(int index, ::google::protobuf::int32 value) {
  repeated_int32_.Set(index, value);
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestAllTypes.repeated_int32)
}
inline void TestAllTypes::add_repeated_int32(::google::protobuf::int32 value) {
  repeated_int32_.Add(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestAllTypes.repeated_int32)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
TestAllTypes::repeated_int32() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestAllTypes.repeated_int32)
  return repeated_int32_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
TestAllTypes::mutable_repeated_int32() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestAllTypes.repeated_int32)
  return &repeated_int32_;
}

// repeated int64 repeated_int64 = 32;
inline int TestAllTypes::repeated_int64_size() const {
  return repeated_int64_.size();
}
inline void TestAllTypes::clear_repeated_int64() {
  repeated_int64_.Clear();
}
inline ::google::protobuf::int64 TestAllTypes::repeated_int64(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestAllTypes.repeated_int64)
  return repeated_int64_.Get(index);
}
inline void TestAllTypes::set_repeated_int64(int index, ::google::protobuf::int64 value) {
  repeated_int64_.Set(index, value);
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestAllTypes.repeated_int64)
}
inline void TestAllTypes::add_repeated_int64(::google::protobuf::int64 value) {
  repeated_int64_.Add(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestAllTypes.repeated_int64)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
TestAllTypes::repeated_int64() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestAllTypes.repeated_int64)
  return repeated_int64_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
TestAllTypes::mutable_repeated_int64() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestAllTypes.repeated_int64)
  return &repeated_int64_;
}

// repeated uint32 repeated_uint32 = 33;
inline int TestAllTypes::repeated_uint32_size() const {
  return repeated_uint32_.size();
}
inline void TestAllTypes::clear_repeated_uint32() {
  repeated_uint32_.Clear();
}
inline ::google::protobuf::uint32 TestAllTypes::repeated_uint32(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestAllTypes.repeated_uint32)
  return repeated_uint32_.Get(index);
}
inline void TestAllTypes::set_repeated_uint32(int index, ::google::protobuf::uint32 value) {
  repeated_uint32_.Set(index, value);
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestAllTypes.repeated_uint32)
}
inline void TestAllTypes::add_repeated_uint32(::google::protobuf::uint32 value) {
  repeated_uint32_.Add(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestAllTypes.repeated_uint32)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
TestAllTypes::repeated_uint32() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestAllTypes.repeated_uint32)
  return repeated_uint32_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
TestAllTypes::mutable_repeated_uint32() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestAllTypes.repeated_uint32)
  return &repeated_uint32_;
}

// repeated uint64 repeated_uint64 = 34;
inline int TestAllTypes::repeated_uint64_size() const {
  return repeated_uint64_.size();
}
inline void TestAllTypes::clear_repeated_uint64() {
  repeated_uint64_.Clear();
}
inline ::google::protobuf::uint64 TestAllTypes::repeated_uint64(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestAllTypes.repeated_uint64)
  return repeated_uint64_.Get(index);
}
inline void TestAllTypes::set_repeated_uint64(int index, ::google::protobuf::uint64 value) {
  repeated_uint64_.Set(index, value);
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestAllTypes.repeated_uint64)
}
inline void TestAllTypes::add_repeated_uint64(::google::protobuf::uint64 value) {
  repeated_uint64_.Add(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestAllTypes.repeated_uint64)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >&
TestAllTypes::repeated_uint64() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestAllTypes.repeated_uint64)
  return repeated_uint64_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >*
TestAllTypes::mutable_repeated_uint64() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestAllTypes.repeated_uint64)
  return &repeated_uint64_;
}

// repeated sint32 repeated_sint32 = 35;
inline int TestAllTypes::repeated_sint32_size() const {
  return repeated_sint32_.size();
}
inline void TestAllTypes::clear_repeated_sint32() {
  repeated_sint32_.Clear();
}
inline ::google::protobuf::int32 TestAllTypes::repeated_sint32(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestAllTypes.repeated_sint32)
  return repeated_sint32_.Get(index);
}
inline void TestAllTypes::set_repeated_sint32(int index, ::google::protobuf::int32 value) {
  repeated_sint32_.Set(index, value);
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestAllTypes.repeated_sint32)
}
inline void TestAllTypes::add_repeated_sint32(::google::protobuf::int32 value) {
  repeated_sint32_.Add(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestAllTypes.repeated_sint32)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
TestAllTypes::repeated_sint32() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestAllTypes.repeated_sint32)
  return repeated_sint32_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
TestAllTypes::mutable_repeated_sint32() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestAllTypes.repeated_sint32)
  return &repeated_sint32_;
}

// repeated sint64 repeated_sint64 = 36;
inline int TestAllTypes::repeated_sint64_size() const {
  return repeated_sint64_.size();
}
inline void TestAllTypes::clear_repeated_sint64() {
  repeated_sint64_.Clear();
}
inline ::google::protobuf::int64 TestAllTypes::repeated_sint64(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestAllTypes.repeated_sint64)
  return repeated_sint64_.Get(index);
}
inline void TestAllTypes::set_repeated_sint64(int index, ::google::protobuf::int64 value) {
  repeated_sint64_.Set(index, value);
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestAllTypes.repeated_sint64)
}
inline void TestAllTypes::add_repeated_sint64(::google::protobuf::int64 value) {
  repeated_sint64_.Add(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestAllTypes.repeated_sint64)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
TestAllTypes::repeated_sint64() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestAllTypes.repeated_sint64)
  return repeated_sint64_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
TestAllTypes::mutable_repeated_sint64() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestAllTypes.repeated_sint64)
  return &repeated_sint64_;
}

// repeated fixed32 repeated_fixed32 = 37;
inline int TestAllTypes::repeated_fixed32_size() const {
  return repeated_fixed32_.size();
}
inline void TestAllTypes::clear_repeated_fixed32() {
  repeated_fixed32_.Clear();
}
inline ::google::protobuf::uint32 TestAllTypes::repeated_fixed32(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestAllTypes.repeated_fixed32)
  return repeated_fixed32_.Get(index);
}
inline void TestAllTypes::set_repeated_fixed32(int index, ::google::protobuf::uint32 value) {
  repeated_fixed32_.Set(index, value);
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestAllTypes.repeated_fixed32)
}
inline void TestAllTypes::add_repeated_fixed32(::google::protobuf::uint32 value) {
  repeated_fixed32_.Add(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestAllTypes.repeated_fixed32)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
TestAllTypes::repeated_fixed32() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestAllTypes.repeated_fixed32)
  return repeated_fixed32_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
TestAllTypes::mutable_repeated_fixed32() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestAllTypes.repeated_fixed32)
  return &repeated_fixed32_;
}

// repeated fixed64 repeated_fixed64 = 38;
inline int TestAllTypes::repeated_fixed64_size() const {
  return repeated_fixed64_.size();
}
inline void TestAllTypes::clear_repeated_fixed64() {
  repeated_fixed64_.Clear();
}
inline ::google::protobuf::uint64 TestAllTypes::repeated_fixed64(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestAllTypes.repeated_fixed64)
  return repeated_fixed64_.Get(index);
}
inline void TestAllTypes::set_repeated_fixed64(int index, ::google::protobuf::uint64 value) {
  repeated_fixed64_.Set(index, value);
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestAllTypes.repeated_fixed64)
}
inline void TestAllTypes::add_repeated_fixed64(::google::protobuf::uint64 value) {
  repeated_fixed64_.Add(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestAllTypes.repeated_fixed64)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >&
TestAllTypes::repeated_fixed64() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestAllTypes.repeated_fixed64)
  return repeated_fixed64_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >*
TestAllTypes::mutable_repeated_fixed64() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestAllTypes.repeated_fixed64)
  return &repeated_fixed64_;
}

// repeated sfixed32 repeated_sfixed32 = 39;
inline int TestAllTypes::repeated_sfixed32_size() const {
  return repeated_sfixed32_.size();
}
inline void TestAllTypes::clear_repeated_sfixed32() {
  repeated_sfixed32_.Clear();
}
inline ::google::protobuf::int32 TestAllTypes::repeated_sfixed32(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestAllTypes.repeated_sfixed32)
  return repeated_sfixed32_.Get(index);
}
inline void TestAllTypes::set_repeated_sfixed32(int index, ::google::protobuf::int32 value) {
  repeated_sfixed32_.Set(index, value);
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestAllTypes.repeated_sfixed32)
}
inline void TestAllTypes::add_repeated_sfixed32(::google::protobuf::int32 value) {
  repeated_sfixed32_.Add(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestAllTypes.repeated_sfixed32)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
TestAllTypes::repeated_sfixed32() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestAllTypes.repeated_sfixed32)
  return repeated_sfixed32_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
TestAllTypes::mutable_repeated_sfixed32() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestAllTypes.repeated_sfixed32)
  return &repeated_sfixed32_;
}

// repeated sfixed64 repeated_sfixed64 = 40;
inline int TestAllTypes::repeated_sfixed64_size() const {
  return repeated_sfixed64_.size();
}
inline void TestAllTypes::clear_repeated_sfixed64() {
  repeated_sfixed64_.Clear();
}
inline ::google::protobuf::int64 TestAllTypes::repeated_sfixed64(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestAllTypes.repeated_sfixed64)
  return repeated_sfixed64_.Get(index);
}
inline void TestAllTypes::set_repeated_sfixed64(int index, ::google::protobuf::int64 value) {
  repeated_sfixed64_.Set(index, value);
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestAllTypes.repeated_sfixed64)
}
inline void TestAllTypes::add_repeated_sfixed64(::google::protobuf::int64 value) {
  repeated_sfixed64_.Add(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestAllTypes.repeated_sfixed64)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
TestAllTypes::repeated_sfixed64() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestAllTypes.repeated_sfixed64)
  return repeated_sfixed64_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
TestAllTypes::mutable_repeated_sfixed64() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestAllTypes.repeated_sfixed64)
  return &repeated_sfixed64_;
}

// repeated float repeated_float = 41;
inline int TestAllTypes::repeated_float_size() const {
  return repeated_float_.size();
}
inline void TestAllTypes::clear_repeated_float() {
  repeated_float_.Clear();
}
inline float TestAllTypes::repeated_float(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestAllTypes.repeated_float)
  return repeated_float_.Get(index);
}
inline void TestAllTypes::set_repeated_float(int index, float value) {
  repeated_float_.Set(index, value);
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestAllTypes.repeated_float)
}
inline void TestAllTypes::add_repeated_float(float value) {
  repeated_float_.Add(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestAllTypes.repeated_float)
}
inline const ::google::protobuf::RepeatedField< float >&
TestAllTypes::repeated_float() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestAllTypes.repeated_float)
  return repeated_float_;
}
inline ::google::protobuf::RepeatedField< float >*
TestAllTypes::mutable_repeated_float() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestAllTypes.repeated_float)
  return &repeated_float_;
}

// repeated double repeated_double = 42;
inline int TestAllTypes::repeated_double_size() const {
  return repeated_double_.size();
}
inline void TestAllTypes::clear_repeated_double() {
  repeated_double_.Clear();
}
inline double TestAllTypes::repeated_double(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestAllTypes.repeated_double)
  return repeated_double_.Get(index);
}
inline void TestAllTypes::set_repeated_double(int index, double value) {
  repeated_double_.Set(index, value);
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestAllTypes.repeated_double)
}
inline void TestAllTypes::add_repeated_double(double value) {
  repeated_double_.Add(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestAllTypes.repeated_double)
}
inline const ::google::protobuf::RepeatedField< double >&
TestAllTypes::repeated_double() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestAllTypes.repeated_double)
  return repeated_double_;
}
inline ::google::protobuf::RepeatedField< double >*
TestAllTypes::mutable_repeated_double() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestAllTypes.repeated_double)
  return &repeated_double_;
}

// repeated bool repeated_bool = 43;
inline int TestAllTypes::repeated_bool_size() const {
  return repeated_bool_.size();
}
inline void TestAllTypes::clear_repeated_bool() {
  repeated_bool_.Clear();
}
inline bool TestAllTypes::repeated_bool(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestAllTypes.repeated_bool)
  return repeated_bool_.Get(index);
}
inline void TestAllTypes::set_repeated_bool(int index, bool value) {
  repeated_bool_.Set(index, value);
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestAllTypes.repeated_bool)
}
inline void TestAllTypes::add_repeated_bool(bool value) {
  repeated_bool_.Add(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestAllTypes.repeated_bool)
}
inline const ::google::protobuf::RepeatedField< bool >&
TestAllTypes::repeated_bool() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestAllTypes.repeated_bool)
  return repeated_bool_;
}
inline ::google::protobuf::RepeatedField< bool >*
TestAllTypes::mutable_repeated_bool() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestAllTypes.repeated_bool)
  return &repeated_bool_;
}

// repeated string repeated_string = 44;
inline int TestAllTypes::repeated_string_size() const {
  return repeated_string_.size();
}
inline void TestAllTypes::clear_repeated_string() {
  repeated_string_.Clear();
}
inline const ::std::string& TestAllTypes::repeated_string(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestAllTypes.repeated_string)
  return repeated_string_.Get(index);
}
inline ::std::string* TestAllTypes::mutable_repeated_string(int index) {
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestAllTypes.repeated_string)
  return repeated_string_.Mutable(index);
}
inline void TestAllTypes::set_repeated_string(int index, const ::std::string& value) {
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestAllTypes.repeated_string)
  repeated_string_.Mutable(index)->assign(value);
}
#if LANG_CXX11
inline void TestAllTypes::set_repeated_string(int index, ::std::string&& value) {
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestAllTypes.repeated_string)
  repeated_string_.Mutable(index)->assign(std::move(value));
}
#endif
inline void TestAllTypes::set_repeated_string(int index, const char* value) {
  GOOGLE_DCHECK(value != NULL);
  repeated_string_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:protobuf_unittest.TestAllTypes.repeated_string)
}
inline void TestAllTypes::set_repeated_string(int index, const char* value, size_t size) {
  repeated_string_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:protobuf_unittest.TestAllTypes.repeated_string)
}
inline ::std::string* TestAllTypes::add_repeated_string() {
  // @@protoc_insertion_point(field_add_mutable:protobuf_unittest.TestAllTypes.repeated_string)
  return repeated_string_.Add();
}
inline void TestAllTypes::add_repeated_string(const ::std::string& value) {
  repeated_string_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestAllTypes.repeated_string)
}
#if LANG_CXX11
inline void TestAllTypes::add_repeated_string(::std::string&& value) {
  repeated_string_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestAllTypes.repeated_string)
}
#endif
inline void TestAllTypes::add_repeated_string(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  repeated_string_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:protobuf_unittest.TestAllTypes.repeated_string)
}
inline void TestAllTypes::add_repeated_string(const char* value, size_t size) {
  repeated_string_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:protobuf_unittest.TestAllTypes.repeated_string)
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
TestAllTypes::repeated_string() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestAllTypes.repeated_string)
  return repeated_string_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
TestAllTypes::mutable_repeated_string() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestAllTypes.repeated_string)
  return &repeated_string_;
}

// repeated bytes repeated_bytes = 45;
inline int TestAllTypes::repeated_bytes_size() const {
  return repeated_bytes_.size();
}
inline void TestAllTypes::clear_repeated_bytes() {
  repeated_bytes_.Clear();
}
inline const ::std::string& TestAllTypes::repeated_bytes(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestAllTypes.repeated_bytes)
  return repeated_bytes_.Get(index);
}
inline ::std::string* TestAllTypes::mutable_repeated_bytes(int index) {
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestAllTypes.repeated_bytes)
  return repeated_bytes_.Mutable(index);
}
inline void TestAllTypes::set_repeated_bytes(int index, const ::std::string& value) {
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestAllTypes.repeated_bytes)
  repeated_bytes_.Mutable(index)->assign(value);
}
#if LANG_CXX11
inline void TestAllTypes::set_repeated_bytes(int index, ::std::string&& value) {
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestAllTypes.repeated_bytes)
  repeated_bytes_.Mutable(index)->assign(std::move(value));
}
#endif
inline void TestAllTypes::set_repeated_bytes(int index, const char* value) {
  GOOGLE_DCHECK(value != NULL);
  repeated_bytes_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:protobuf_unittest.TestAllTypes.repeated_bytes)
}
inline void TestAllTypes::set_repeated_bytes(int index, const void* value, size_t size) {
  repeated_bytes_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:protobuf_unittest.TestAllTypes.repeated_bytes)
}
inline ::std::string* TestAllTypes::add_repeated_bytes() {
  // @@protoc_insertion_point(field_add_mutable:protobuf_unittest.TestAllTypes.repeated_bytes)
  return repeated_bytes_.Add();
}
inline void TestAllTypes::add_repeated_bytes(const ::std::string& value) {
  repeated_bytes_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestAllTypes.repeated_bytes)
}
#if LANG_CXX11
inline void TestAllTypes::add_repeated_bytes(::std::string&& value) {
  repeated_bytes_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestAllTypes.repeated_bytes)
}
#endif
inline void TestAllTypes::add_repeated_bytes(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  repeated_bytes_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:protobuf_unittest.TestAllTypes.repeated_bytes)
}
inline void TestAllTypes::add_repeated_bytes(const void* value, size_t size) {
  repeated_bytes_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:protobuf_unittest.TestAllTypes.repeated_bytes)
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
TestAllTypes::repeated_bytes() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestAllTypes.repeated_bytes)
  return repeated_bytes_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
TestAllTypes::mutable_repeated_bytes() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestAllTypes.repeated_bytes)
  return &repeated_bytes_;
}

// repeated group RepeatedGroup = 46 { ... };
inline int TestAllTypes::repeatedgroup_size() const {
  return repeatedgroup_.size();
}
inline void TestAllTypes::clear_repeatedgroup() {
  repeatedgroup_.Clear();
}
inline ::protobuf_unittest::TestAllTypes_RepeatedGroup* TestAllTypes::mutable_repeatedgroup(int index) {
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestAllTypes.repeatedgroup)
  return repeatedgroup_.Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::TestAllTypes_RepeatedGroup >*
TestAllTypes::mutable_repeatedgroup() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestAllTypes.repeatedgroup)
  return &repeatedgroup_;
}
inline const ::protobuf_unittest::TestAllTypes_RepeatedGroup& TestAllTypes::repeatedgroup(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestAllTypes.repeatedgroup)
  return repeatedgroup_.Get(index);
}
inline ::protobuf_unittest::TestAllTypes_RepeatedGroup* TestAllTypes::add_repeatedgroup() {
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestAllTypes.repeatedgroup)
  return repeatedgroup_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::TestAllTypes_RepeatedGroup >&
TestAllTypes::repeatedgroup() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestAllTypes.repeatedgroup)
  return repeatedgroup_;
}

// repeated .protobuf_unittest.TestAllTypes.NestedMessage repeated_nested_message = 48;
inline int TestAllTypes::repeated_nested_message_size() const {
  return repeated_nested_message_.size();
}
inline void TestAllTypes::clear_repeated_nested_message() {
  repeated_nested_message_.Clear();
}
inline ::protobuf_unittest::TestAllTypes_NestedMessage* TestAllTypes::mutable_repeated_nested_message(int index) {
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestAllTypes.repeated_nested_message)
  return repeated_nested_message_.Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::TestAllTypes_NestedMessage >*
TestAllTypes::mutable_repeated_nested_message() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestAllTypes.repeated_nested_message)
  return &repeated_nested_message_;
}
inline const ::protobuf_unittest::TestAllTypes_NestedMessage& TestAllTypes::repeated_nested_message(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestAllTypes.repeated_nested_message)
  return repeated_nested_message_.Get(index);
}
inline ::protobuf_unittest::TestAllTypes_NestedMessage* TestAllTypes::add_repeated_nested_message() {
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestAllTypes.repeated_nested_message)
  return repeated_nested_message_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::TestAllTypes_NestedMessage >&
TestAllTypes::repeated_nested_message() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestAllTypes.repeated_nested_message)
  return repeated_nested_message_;
}

// repeated .protobuf_unittest.ForeignMessage repeated_foreign_message = 49;
inline int TestAllTypes::repeated_foreign_message_size() const {
  return repeated_foreign_message_.size();
}
inline void TestAllTypes::clear_repeated_foreign_message() {
  repeated_foreign_message_.Clear();
}
inline ::protobuf_unittest::ForeignMessage* TestAllTypes::mutable_repeated_foreign_message(int index) {
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestAllTypes.repeated_foreign_message)
  return repeated_foreign_message_.Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::ForeignMessage >*
TestAllTypes::mutable_repeated_foreign_message() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestAllTypes.repeated_foreign_message)
  return &repeated_foreign_message_;
}
inline const ::protobuf_unittest::ForeignMessage& TestAllTypes::repeated_foreign_message(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestAllTypes.repeated_foreign_message)
  return repeated_foreign_message_.Get(index);
}
inline ::protobuf_unittest::ForeignMessage* TestAllTypes::add_repeated_foreign_message() {
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestAllTypes.repeated_foreign_message)
  return repeated_foreign_message_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::ForeignMessage >&
TestAllTypes::repeated_foreign_message() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestAllTypes.repeated_foreign_message)
  return repeated_foreign_message_;
}

// repeated .protobuf_unittest_import.ImportMessage repeated_import_message = 50;
inline int TestAllTypes::repeated_import_message_size() const {
  return repeated_import_message_.size();
}
inline ::protobuf_unittest_import::ImportMessage* TestAllTypes::mutable_repeated_import_message(int index) {
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestAllTypes.repeated_import_message)
  return repeated_import_message_.Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField< ::protobuf_unittest_import::ImportMessage >*
TestAllTypes::mutable_repeated_import_message() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestAllTypes.repeated_import_message)
  return &repeated_import_message_;
}
inline const ::protobuf_unittest_import::ImportMessage& TestAllTypes::repeated_import_message(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestAllTypes.repeated_import_message)
  return repeated_import_message_.Get(index);
}
inline ::protobuf_unittest_import::ImportMessage* TestAllTypes::add_repeated_import_message() {
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestAllTypes.repeated_import_message)
  return repeated_import_message_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::protobuf_unittest_import::ImportMessage >&
TestAllTypes::repeated_import_message() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestAllTypes.repeated_import_message)
  return repeated_import_message_;
}

// repeated .protobuf_unittest.TestAllTypes.NestedEnum repeated_nested_enum = 51;
inline int TestAllTypes::repeated_nested_enum_size() const {
  return repeated_nested_enum_.size();
}
inline void TestAllTypes::clear_repeated_nested_enum() {
  repeated_nested_enum_.Clear();
}
inline ::protobuf_unittest::TestAllTypes_NestedEnum TestAllTypes::repeated_nested_enum(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestAllTypes.repeated_nested_enum)
  return static_cast< ::protobuf_unittest::TestAllTypes_NestedEnum >(repeated_nested_enum_.Get(index));
}
inline void TestAllTypes::set_repeated_nested_enum(int index, ::protobuf_unittest::TestAllTypes_NestedEnum value) {
  assert(::protobuf_unittest::TestAllTypes_NestedEnum_IsValid(value));
  repeated_nested_enum_.Set(index, value);
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestAllTypes.repeated_nested_enum)
}
inline void TestAllTypes::add_repeated_nested_enum(::protobuf_unittest::TestAllTypes_NestedEnum value) {
  assert(::protobuf_unittest::TestAllTypes_NestedEnum_IsValid(value));
  repeated_nested_enum_.Add(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestAllTypes.repeated_nested_enum)
}
inline const ::google::protobuf::RepeatedField<int>&
TestAllTypes::repeated_nested_enum() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestAllTypes.repeated_nested_enum)
  return repeated_nested_enum_;
}
inline ::google::protobuf::RepeatedField<int>*
TestAllTypes::mutable_repeated_nested_enum() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestAllTypes.repeated_nested_enum)
  return &repeated_nested_enum_;
}

// repeated .protobuf_unittest.ForeignEnum repeated_foreign_enum = 52;
inline int TestAllTypes::repeated_foreign_enum_size() const {
  return repeated_foreign_enum_.size();
}
inline void TestAllTypes::clear_repeated_foreign_enum() {
  repeated_foreign_enum_.Clear();
}
inline ::protobuf_unittest::ForeignEnum TestAllTypes::repeated_foreign_enum(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestAllTypes.repeated_foreign_enum)
  return static_cast< ::protobuf_unittest::ForeignEnum >(repeated_foreign_enum_.Get(index));
}
inline void TestAllTypes::set_repeated_foreign_enum(int index, ::protobuf_unittest::ForeignEnum value) {
  assert(::protobuf_unittest::ForeignEnum_IsValid(value));
  repeated_foreign_enum_.Set(index, value);
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestAllTypes.repeated_foreign_enum)
}
inline void TestAllTypes::add_repeated_foreign_enum(::protobuf_unittest::ForeignEnum value) {
  assert(::protobuf_unittest::ForeignEnum_IsValid(value));
  repeated_foreign_enum_.Add(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestAllTypes.repeated_foreign_enum)
}
inline const ::google::protobuf::RepeatedField<int>&
TestAllTypes::repeated_foreign_enum() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestAllTypes.repeated_foreign_enum)
  return repeated_foreign_enum_;
}
inline ::google::protobuf::RepeatedField<int>*
TestAllTypes::mutable_repeated_foreign_enum() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestAllTypes.repeated_foreign_enum)
  return &repeated_foreign_enum_;
}

// repeated .protobuf_unittest_import.ImportEnum repeated_import_enum = 53;
inline int TestAllTypes::repeated_import_enum_size() const {
  return repeated_import_enum_.size();
}
inline void TestAllTypes::clear_repeated_import_enum() {
  repeated_import_enum_.Clear();
}
inline ::protobuf_unittest_import::ImportEnum TestAllTypes::repeated_import_enum(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestAllTypes.repeated_import_enum)
  return static_cast< ::protobuf_unittest_import::ImportEnum >(repeated_import_enum_.Get(index));
}
inline void TestAllTypes::set_repeated_import_enum(int index, ::protobuf_unittest_import::ImportEnum value) {
  assert(::protobuf_unittest_import::ImportEnum_IsValid(value));
  repeated_import_enum_.Set(index, value);
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestAllTypes.repeated_import_enum)
}
inline void TestAllTypes::add_repeated_import_enum(::protobuf_unittest_import::ImportEnum value) {
  assert(::protobuf_unittest_import::ImportEnum_IsValid(value));
  repeated_import_enum_.Add(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestAllTypes.repeated_import_enum)
}
inline const ::google::protobuf::RepeatedField<int>&
TestAllTypes::repeated_import_enum() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestAllTypes.repeated_import_enum)
  return repeated_import_enum_;
}
inline ::google::protobuf::RepeatedField<int>*
TestAllTypes::mutable_repeated_import_enum() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestAllTypes.repeated_import_enum)
  return &repeated_import_enum_;
}

// repeated string repeated_string_piece = 54 [ctype = STRING_PIECE];
inline int TestAllTypes::repeated_string_piece_size() const {
  return repeated_string_piece_.size();
}
inline void TestAllTypes::clear_repeated_string_piece() {
  repeated_string_piece_.Clear();
}
inline const ::std::string& TestAllTypes::repeated_string_piece(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestAllTypes.repeated_string_piece)
  return repeated_string_piece_.Get(index);
}
inline ::std::string* TestAllTypes::mutable_repeated_string_piece(int index) {
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestAllTypes.repeated_string_piece)
  return repeated_string_piece_.Mutable(index);
}
inline void TestAllTypes::set_repeated_string_piece(int index, const ::std::string& value) {
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestAllTypes.repeated_string_piece)
  repeated_string_piece_.Mutable(index)->assign(value);
}
#if LANG_CXX11
inline void TestAllTypes::set_repeated_string_piece(int index, ::std::string&& value) {
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestAllTypes.repeated_string_piece)
  repeated_string_piece_.Mutable(index)->assign(std::move(value));
}
#endif
inline void TestAllTypes::set_repeated_string_piece(int index, const char* value) {
  GOOGLE_DCHECK(value != NULL);
  repeated_string_piece_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:protobuf_unittest.TestAllTypes.repeated_string_piece)
}
inline void TestAllTypes::set_repeated_string_piece(int index, const char* value, size_t size) {
  repeated_string_piece_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:protobuf_unittest.TestAllTypes.repeated_string_piece)
}
inline ::std::string* TestAllTypes::add_repeated_string_piece() {
  // @@protoc_insertion_point(field_add_mutable:protobuf_unittest.TestAllTypes.repeated_string_piece)
  return repeated_string_piece_.Add();
}
inline void TestAllTypes::add_repeated_string_piece(const ::std::string& value) {
  repeated_string_piece_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestAllTypes.repeated_string_piece)
}
#if LANG_CXX11
inline void TestAllTypes::add_repeated_string_piece(::std::string&& value) {
  repeated_string_piece_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestAllTypes.repeated_string_piece)
}
#endif
inline void TestAllTypes::add_repeated_string_piece(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  repeated_string_piece_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:protobuf_unittest.TestAllTypes.repeated_string_piece)
}
inline void TestAllTypes::add_repeated_string_piece(const char* value, size_t size) {
  repeated_string_piece_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:protobuf_unittest.TestAllTypes.repeated_string_piece)
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
TestAllTypes::repeated_string_piece() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestAllTypes.repeated_string_piece)
  return repeated_string_piece_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
TestAllTypes::mutable_repeated_string_piece() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestAllTypes.repeated_string_piece)
  return &repeated_string_piece_;
}

// repeated string repeated_cord = 55 [ctype = CORD];
inline int TestAllTypes::repeated_cord_size() const {
  return repeated_cord_.size();
}
inline void TestAllTypes::clear_repeated_cord() {
  repeated_cord_.Clear();
}
inline const ::std::string& TestAllTypes::repeated_cord(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestAllTypes.repeated_cord)
  return repeated_cord_.Get(index);
}
inline ::std::string* TestAllTypes::mutable_repeated_cord(int index) {
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestAllTypes.repeated_cord)
  return repeated_cord_.Mutable(index);
}
inline void TestAllTypes::set_repeated_cord(int index, const ::std::string& value) {
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestAllTypes.repeated_cord)
  repeated_cord_.Mutable(index)->assign(value);
}
#if LANG_CXX11
inline void TestAllTypes::set_repeated_cord(int index, ::std::string&& value) {
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestAllTypes.repeated_cord)
  repeated_cord_.Mutable(index)->assign(std::move(value));
}
#endif
inline void TestAllTypes::set_repeated_cord(int index, const char* value) {
  GOOGLE_DCHECK(value != NULL);
  repeated_cord_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:protobuf_unittest.TestAllTypes.repeated_cord)
}
inline void TestAllTypes::set_repeated_cord(int index, const char* value, size_t size) {
  repeated_cord_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:protobuf_unittest.TestAllTypes.repeated_cord)
}
inline ::std::string* TestAllTypes::add_repeated_cord() {
  // @@protoc_insertion_point(field_add_mutable:protobuf_unittest.TestAllTypes.repeated_cord)
  return repeated_cord_.Add();
}
inline void TestAllTypes::add_repeated_cord(const ::std::string& value) {
  repeated_cord_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestAllTypes.repeated_cord)
}
#if LANG_CXX11
inline void TestAllTypes::add_repeated_cord(::std::string&& value) {
  repeated_cord_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestAllTypes.repeated_cord)
}
#endif
inline void TestAllTypes::add_repeated_cord(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  repeated_cord_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:protobuf_unittest.TestAllTypes.repeated_cord)
}
inline void TestAllTypes::add_repeated_cord(const char* value, size_t size) {
  repeated_cord_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:protobuf_unittest.TestAllTypes.repeated_cord)
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
TestAllTypes::repeated_cord() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestAllTypes.repeated_cord)
  return repeated_cord_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
TestAllTypes::mutable_repeated_cord() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestAllTypes.repeated_cord)
  return &repeated_cord_;
}

// repeated .protobuf_unittest.TestAllTypes.NestedMessage repeated_lazy_message = 57 [lazy = true];
inline int TestAllTypes::repeated_lazy_message_size() const {
  return repeated_lazy_message_.size();
}
inline void TestAllTypes::clear_repeated_lazy_message() {
  repeated_lazy_message_.Clear();
}
inline ::protobuf_unittest::TestAllTypes_NestedMessage* TestAllTypes::mutable_repeated_lazy_message(int index) {
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestAllTypes.repeated_lazy_message)
  return repeated_lazy_message_.Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::TestAllTypes_NestedMessage >*
TestAllTypes::mutable_repeated_lazy_message() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestAllTypes.repeated_lazy_message)
  return &repeated_lazy_message_;
}
inline const ::protobuf_unittest::TestAllTypes_NestedMessage& TestAllTypes::repeated_lazy_message(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestAllTypes.repeated_lazy_message)
  return repeated_lazy_message_.Get(index);
}
inline ::protobuf_unittest::TestAllTypes_NestedMessage* TestAllTypes::add_repeated_lazy_message() {
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestAllTypes.repeated_lazy_message)
  return repeated_lazy_message_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::TestAllTypes_NestedMessage >&
TestAllTypes::repeated_lazy_message() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestAllTypes.repeated_lazy_message)
  return repeated_lazy_message_;
}

// optional int32 default_int32 = 61 [default = 41];
inline bool TestAllTypes::has_default_int32() const {
  return (_has_bits_[0] & 0x80000000u) != 0;
}
inline void TestAllTypes::set_has_default_int32() {
  _has_bits_[0] |= 0x80000000u;
}
inline void TestAllTypes::clear_has_default_int32() {
  _has_bits_[0] &= ~0x80000000u;
}
inline void TestAllTypes::clear_default_int32() {
  default_int32_ = 41;
  clear_has_default_int32();
}
inline ::google::protobuf::int32 TestAllTypes::default_int32() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestAllTypes.default_int32)
  return default_int32_;
}
inline void TestAllTypes::set_default_int32(::google::protobuf::int32 value) {
  set_has_default_int32();
  default_int32_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestAllTypes.default_int32)
}

// optional int64 default_int64 = 62 [default = 42];
inline bool TestAllTypes::has_default_int64() const {
  return (_has_bits_[1] & 0x00000001u) != 0;
}
inline void TestAllTypes::set_has_default_int64() {
  _has_bits_[1] |= 0x00000001u;
}
inline void TestAllTypes::clear_has_default_int64() {
  _has_bits_[1] &= ~0x00000001u;
}
inline void TestAllTypes::clear_default_int64() {
  default_int64_ = GOOGLE_LONGLONG(42);
  clear_has_default_int64();
}
inline ::google::protobuf::int64 TestAllTypes::default_int64() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestAllTypes.default_int64)
  return default_int64_;
}
inline void TestAllTypes::set_default_int64(::google::protobuf::int64 value) {
  set_has_default_int64();
  default_int64_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestAllTypes.default_int64)
}

// optional uint32 default_uint32 = 63 [default = 43];
inline bool TestAllTypes::has_default_uint32() const {
  return (_has_bits_[1] & 0x00000004u) != 0;
}
inline void TestAllTypes::set_has_default_uint32() {
  _has_bits_[1] |= 0x00000004u;
}
inline void TestAllTypes::clear_has_default_uint32() {
  _has_bits_[1] &= ~0x00000004u;
}
inline void TestAllTypes::clear_default_uint32() {
  default_uint32_ = 43u;
  clear_has_default_uint32();
}
inline ::google::protobuf::uint32 TestAllTypes::default_uint32() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestAllTypes.default_uint32)
  return default_uint32_;
}
inline void TestAllTypes::set_default_uint32(::google::protobuf::uint32 value) {
  set_has_default_uint32();
  default_uint32_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestAllTypes.default_uint32)
}

// optional uint64 default_uint64 = 64 [default = 44];
inline bool TestAllTypes::has_default_uint64() const {
  return (_has_bits_[1] & 0x00000002u) != 0;
}
inline void TestAllTypes::set_has_default_uint64() {
  _has_bits_[1] |= 0x00000002u;
}
inline void TestAllTypes::clear_has_default_uint64() {
  _has_bits_[1] &= ~0x00000002u;
}
inline void TestAllTypes::clear_default_uint64() {
  default_uint64_ = GOOGLE_ULONGLONG(44);
  clear_has_default_uint64();
}
inline ::google::protobuf::uint64 TestAllTypes::default_uint64() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestAllTypes.default_uint64)
  return default_uint64_;
}
inline void TestAllTypes::set_default_uint64(::google::protobuf::uint64 value) {
  set_has_default_uint64();
  default_uint64_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestAllTypes.default_uint64)
}

// optional sint32 default_sint32 = 65 [default = -45];
inline bool TestAllTypes::has_default_sint32() const {
  return (_has_bits_[1] & 0x00000008u) != 0;
}
inline void TestAllTypes::set_has_default_sint32() {
  _has_bits_[1] |= 0x00000008u;
}
inline void TestAllTypes::clear_has_default_sint32() {
  _has_bits_[1] &= ~0x00000008u;
}
inline void TestAllTypes::clear_default_sint32() {
  default_sint32_ = -45;
  clear_has_default_sint32();
}
inline ::google::protobuf::int32 TestAllTypes::default_sint32() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestAllTypes.default_sint32)
  return default_sint32_;
}
inline void TestAllTypes::set_default_sint32(::google::protobuf::int32 value) {
  set_has_default_sint32();
  default_sint32_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestAllTypes.default_sint32)
}

// optional sint64 default_sint64 = 66 [default = 46];
inline bool TestAllTypes::has_default_sint64() const {
  return (_has_bits_[1] & 0x00000010u) != 0;
}
inline void TestAllTypes::set_has_default_sint64() {
  _has_bits_[1] |= 0x00000010u;
}
inline void TestAllTypes::clear_has_default_sint64() {
  _has_bits_[1] &= ~0x00000010u;
}
inline void TestAllTypes::clear_default_sint64() {
  default_sint64_ = GOOGLE_LONGLONG(46);
  clear_has_default_sint64();
}
inline ::google::protobuf::int64 TestAllTypes::default_sint64() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestAllTypes.default_sint64)
  return default_sint64_;
}
inline void TestAllTypes::set_default_sint64(::google::protobuf::int64 value) {
  set_has_default_sint64();
  default_sint64_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestAllTypes.default_sint64)
}

// optional fixed32 default_fixed32 = 67 [default = 47];
inline bool TestAllTypes::has_default_fixed32() const {
  return (_has_bits_[1] & 0x00000040u) != 0;
}
inline void TestAllTypes::set_has_default_fixed32() {
  _has_bits_[1] |= 0x00000040u;
}
inline void TestAllTypes::clear_has_default_fixed32() {
  _has_bits_[1] &= ~0x00000040u;
}
inline void TestAllTypes::clear_default_fixed32() {
  default_fixed32_ = 47u;
  clear_has_default_fixed32();
}
inline ::google::protobuf::uint32 TestAllTypes::default_fixed32() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestAllTypes.default_fixed32)
  return default_fixed32_;
}
inline void TestAllTypes::set_default_fixed32(::google::protobuf::uint32 value) {
  set_has_default_fixed32();
  default_fixed32_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestAllTypes.default_fixed32)
}

// optional fixed64 default_fixed64 = 68 [default = 48];
inline bool TestAllTypes::has_default_fixed64() const {
  return (_has_bits_[1] & 0x00000020u) != 0;
}
inline void TestAllTypes::set_has_default_fixed64() {
  _has_bits_[1] |= 0x00000020u;
}
inline void TestAllTypes::clear_has_default_fixed64() {
  _has_bits_[1] &= ~0x00000020u;
}
inline void TestAllTypes::clear_default_fixed64() {
  default_fixed64_ = GOOGLE_ULONGLONG(48);
  clear_has_default_fixed64();
}
inline ::google::protobuf::uint64 TestAllTypes::default_fixed64() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestAllTypes.default_fixed64)
  return default_fixed64_;
}
inline void TestAllTypes::set_default_fixed64(::google::protobuf::uint64 value) {
  set_has_default_fixed64();
  default_fixed64_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestAllTypes.default_fixed64)
}

// optional sfixed32 default_sfixed32 = 69 [default = 49];
inline bool TestAllTypes::has_default_sfixed32() const {
  return (_has_bits_[1] & 0x00000080u) != 0;
}
inline void TestAllTypes::set_has_default_sfixed32() {
  _has_bits_[1] |= 0x00000080u;
}
inline void TestAllTypes::clear_has_default_sfixed32() {
  _has_bits_[1] &= ~0x00000080u;
}
inline void TestAllTypes::clear_default_sfixed32() {
  default_sfixed32_ = 49;
  clear_has_default_sfixed32();
}
inline ::google::protobuf::int32 TestAllTypes::default_sfixed32() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestAllTypes.default_sfixed32)
  return default_sfixed32_;
}
inline void TestAllTypes::set_default_sfixed32(::google::protobuf::int32 value) {
  set_has_default_sfixed32();
  default_sfixed32_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestAllTypes.default_sfixed32)
}

// optional sfixed64 default_sfixed64 = 70 [default = -50];
inline bool TestAllTypes::has_default_sfixed64() const {
  return (_has_bits_[1] & 0x00000100u) != 0;
}
inline void TestAllTypes::set_has_default_sfixed64() {
  _has_bits_[1] |= 0x00000100u;
}
inline void TestAllTypes::clear_has_default_sfixed64() {
  _has_bits_[1] &= ~0x00000100u;
}
inline void TestAllTypes::clear_default_sfixed64() {
  default_sfixed64_ = GOOGLE_LONGLONG(-50);
  clear_has_default_sfixed64();
}
inline ::google::protobuf::int64 TestAllTypes::default_sfixed64() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestAllTypes.default_sfixed64)
  return default_sfixed64_;
}
inline void TestAllTypes::set_default_sfixed64(::google::protobuf::int64 value) {
  set_has_default_sfixed64();
  default_sfixed64_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestAllTypes.default_sfixed64)
}

// optional float default_float = 71 [default = 51.5];
inline bool TestAllTypes::has_default_float() const {
  return (_has_bits_[1] & 0x00000400u) != 0;
}
inline void TestAllTypes::set_has_default_float() {
  _has_bits_[1] |= 0x00000400u;
}
inline void TestAllTypes::clear_has_default_float() {
  _has_bits_[1] &= ~0x00000400u;
}
inline void TestAllTypes::clear_default_float() {
  default_float_ = 51.5f;
  clear_has_default_float();
}
inline float TestAllTypes::default_float() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestAllTypes.default_float)
  return default_float_;
}
inline void TestAllTypes::set_default_float(float value) {
  set_has_default_float();
  default_float_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestAllTypes.default_float)
}

// optional double default_double = 72 [default = 52000];
inline bool TestAllTypes::has_default_double() const {
  return (_has_bits_[1] & 0x00000200u) != 0;
}
inline void TestAllTypes::set_has_default_double() {
  _has_bits_[1] |= 0x00000200u;
}
inline void TestAllTypes::clear_has_default_double() {
  _has_bits_[1] &= ~0x00000200u;
}
inline void TestAllTypes::clear_default_double() {
  default_double_ = 52000;
  clear_has_default_double();
}
inline double TestAllTypes::default_double() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestAllTypes.default_double)
  return default_double_;
}
inline void TestAllTypes::set_default_double(double value) {
  set_has_default_double();
  default_double_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestAllTypes.default_double)
}

// optional bool default_bool = 73 [default = true];
inline bool TestAllTypes::has_default_bool() const {
  return (_has_bits_[1] & 0x00000800u) != 0;
}
inline void TestAllTypes::set_has_default_bool() {
  _has_bits_[1] |= 0x00000800u;
}
inline void TestAllTypes::clear_has_default_bool() {
  _has_bits_[1] &= ~0x00000800u;
}
inline void TestAllTypes::clear_default_bool() {
  default_bool_ = true;
  clear_has_default_bool();
}
inline bool TestAllTypes::default_bool() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestAllTypes.default_bool)
  return default_bool_;
}
inline void TestAllTypes::set_default_bool(bool value) {
  set_has_default_bool();
  default_bool_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestAllTypes.default_bool)
}

// optional string default_string = 74 [default = "hello"];
inline bool TestAllTypes::has_default_string() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void TestAllTypes::set_has_default_string() {
  _has_bits_[0] |= 0x00000010u;
}
inline void TestAllTypes::clear_has_default_string() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void TestAllTypes::clear_default_string() {
  default_string_.ClearToDefault(&::protobuf_unittest::TestAllTypes::_i_give_permission_to_break_this_code_default_default_string_.get(), GetArenaNoVirtual());
  clear_has_default_string();
}
inline const ::std::string& TestAllTypes::default_string() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestAllTypes.default_string)
  return default_string_.Get();
}
inline void TestAllTypes::set_default_string(const ::std::string& value) {
  set_has_default_string();
  default_string_.Set(&::protobuf_unittest::TestAllTypes::_i_give_permission_to_break_this_code_default_default_string_.get(), value, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestAllTypes.default_string)
}
#if LANG_CXX11
inline void TestAllTypes::set_default_string(::std::string&& value) {
  set_has_default_string();
  default_string_.Set(
    &::protobuf_unittest::TestAllTypes::_i_give_permission_to_break_this_code_default_default_string_.get(), ::std::move(value), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_rvalue:protobuf_unittest.TestAllTypes.default_string)
}
#endif
inline void TestAllTypes::set_default_string(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_default_string();
  default_string_.Set(&::protobuf_unittest::TestAllTypes::_i_give_permission_to_break_this_code_default_default_string_.get(), ::std::string(value),
              GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_char:protobuf_unittest.TestAllTypes.default_string)
}
inline void TestAllTypes::set_default_string(const char* value,
    size_t size) {
  set_has_default_string();
  default_string_.Set(&::protobuf_unittest::TestAllTypes::_i_give_permission_to_break_this_code_default_default_string_.get(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_pointer:protobuf_unittest.TestAllTypes.default_string)
}
inline ::std::string* TestAllTypes::mutable_default_string() {
  set_has_default_string();
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestAllTypes.default_string)
  return default_string_.Mutable(&::protobuf_unittest::TestAllTypes::_i_give_permission_to_break_this_code_default_default_string_.get(), GetArenaNoVirtual());
}
inline ::std::string* TestAllTypes::release_default_string() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestAllTypes.default_string)
  if (!has_default_string()) {
    return NULL;
  }
  clear_has_default_string();
  return default_string_.ReleaseNonDefault(&::protobuf_unittest::TestAllTypes::_i_give_permission_to_break_this_code_default_default_string_.get(), GetArenaNoVirtual());
}
inline void TestAllTypes::set_allocated_default_string(::std::string* default_string) {
  if (default_string != NULL) {
    set_has_default_string();
  } else {
    clear_has_default_string();
  }
  default_string_.SetAllocated(&::protobuf_unittest::TestAllTypes::_i_give_permission_to_break_this_code_default_default_string_.get(), default_string,
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestAllTypes.default_string)
}
inline ::std::string* TestAllTypes::unsafe_arena_release_default_string() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestAllTypes.default_string)
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  clear_has_default_string();
  return default_string_.UnsafeArenaRelease(&::protobuf_unittest::TestAllTypes::_i_give_permission_to_break_this_code_default_default_string_.get(),
      GetArenaNoVirtual());
}
inline void TestAllTypes::unsafe_arena_set_allocated_default_string(
    ::std::string* default_string) {
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (default_string != NULL) {
    set_has_default_string();
  } else {
    clear_has_default_string();
  }
  default_string_.UnsafeArenaSetAllocated(&::protobuf_unittest::TestAllTypes::_i_give_permission_to_break_this_code_default_default_string_.get(),
      default_string, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf_unittest.TestAllTypes.default_string)
}

// optional bytes default_bytes = 75 [default = "world"];
inline bool TestAllTypes::has_default_bytes() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void TestAllTypes::set_has_default_bytes() {
  _has_bits_[0] |= 0x00000020u;
}
inline void TestAllTypes::clear_has_default_bytes() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void TestAllTypes::clear_default_bytes() {
  default_bytes_.ClearToDefault(&::protobuf_unittest::TestAllTypes::_i_give_permission_to_break_this_code_default_default_bytes_.get(), GetArenaNoVirtual());
  clear_has_default_bytes();
}
inline const ::std::string& TestAllTypes::default_bytes() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestAllTypes.default_bytes)
  return default_bytes_.Get();
}
inline void TestAllTypes::set_default_bytes(const ::std::string& value) {
  set_has_default_bytes();
  default_bytes_.Set(&::protobuf_unittest::TestAllTypes::_i_give_permission_to_break_this_code_default_default_bytes_.get(), value, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestAllTypes.default_bytes)
}
#if LANG_CXX11
inline void TestAllTypes::set_default_bytes(::std::string&& value) {
  set_has_default_bytes();
  default_bytes_.Set(
    &::protobuf_unittest::TestAllTypes::_i_give_permission_to_break_this_code_default_default_bytes_.get(), ::std::move(value), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_rvalue:protobuf_unittest.TestAllTypes.default_bytes)
}
#endif
inline void TestAllTypes::set_default_bytes(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_default_bytes();
  default_bytes_.Set(&::protobuf_unittest::TestAllTypes::_i_give_permission_to_break_this_code_default_default_bytes_.get(), ::std::string(value),
              GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_char:protobuf_unittest.TestAllTypes.default_bytes)
}
inline void TestAllTypes::set_default_bytes(const void* value,
    size_t size) {
  set_has_default_bytes();
  default_bytes_.Set(&::protobuf_unittest::TestAllTypes::_i_give_permission_to_break_this_code_default_default_bytes_.get(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_pointer:protobuf_unittest.TestAllTypes.default_bytes)
}
inline ::std::string* TestAllTypes::mutable_default_bytes() {
  set_has_default_bytes();
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestAllTypes.default_bytes)
  return default_bytes_.Mutable(&::protobuf_unittest::TestAllTypes::_i_give_permission_to_break_this_code_default_default_bytes_.get(), GetArenaNoVirtual());
}
inline ::std::string* TestAllTypes::release_default_bytes() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestAllTypes.default_bytes)
  if (!has_default_bytes()) {
    return NULL;
  }
  clear_has_default_bytes();
  return default_bytes_.ReleaseNonDefault(&::protobuf_unittest::TestAllTypes::_i_give_permission_to_break_this_code_default_default_bytes_.get(), GetArenaNoVirtual());
}
inline void TestAllTypes::set_allocated_default_bytes(::std::string* default_bytes) {
  if (default_bytes != NULL) {
    set_has_default_bytes();
  } else {
    clear_has_default_bytes();
  }
  default_bytes_.SetAllocated(&::protobuf_unittest::TestAllTypes::_i_give_permission_to_break_this_code_default_default_bytes_.get(), default_bytes,
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestAllTypes.default_bytes)
}
inline ::std::string* TestAllTypes::unsafe_arena_release_default_bytes() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestAllTypes.default_bytes)
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  clear_has_default_bytes();
  return default_bytes_.UnsafeArenaRelease(&::protobuf_unittest::TestAllTypes::_i_give_permission_to_break_this_code_default_default_bytes_.get(),
      GetArenaNoVirtual());
}
inline void TestAllTypes::unsafe_arena_set_allocated_default_bytes(
    ::std::string* default_bytes) {
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (default_bytes != NULL) {
    set_has_default_bytes();
  } else {
    clear_has_default_bytes();
  }
  default_bytes_.UnsafeArenaSetAllocated(&::protobuf_unittest::TestAllTypes::_i_give_permission_to_break_this_code_default_default_bytes_.get(),
      default_bytes, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf_unittest.TestAllTypes.default_bytes)
}

// optional .protobuf_unittest.TestAllTypes.NestedEnum default_nested_enum = 81 [default = BAR];
inline bool TestAllTypes::has_default_nested_enum() const {
  return (_has_bits_[1] & 0x00001000u) != 0;
}
inline void TestAllTypes::set_has_default_nested_enum() {
  _has_bits_[1] |= 0x00001000u;
}
inline void TestAllTypes::clear_has_default_nested_enum() {
  _has_bits_[1] &= ~0x00001000u;
}
inline void TestAllTypes::clear_default_nested_enum() {
  default_nested_enum_ = 2;
  clear_has_default_nested_enum();
}
inline ::protobuf_unittest::TestAllTypes_NestedEnum TestAllTypes::default_nested_enum() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestAllTypes.default_nested_enum)
  return static_cast< ::protobuf_unittest::TestAllTypes_NestedEnum >(default_nested_enum_);
}
inline void TestAllTypes::set_default_nested_enum(::protobuf_unittest::TestAllTypes_NestedEnum value) {
  assert(::protobuf_unittest::TestAllTypes_NestedEnum_IsValid(value));
  set_has_default_nested_enum();
  default_nested_enum_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestAllTypes.default_nested_enum)
}

// optional .protobuf_unittest.ForeignEnum default_foreign_enum = 82 [default = FOREIGN_BAR];
inline bool TestAllTypes::has_default_foreign_enum() const {
  return (_has_bits_[1] & 0x00002000u) != 0;
}
inline void TestAllTypes::set_has_default_foreign_enum() {
  _has_bits_[1] |= 0x00002000u;
}
inline void TestAllTypes::clear_has_default_foreign_enum() {
  _has_bits_[1] &= ~0x00002000u;
}
inline void TestAllTypes::clear_default_foreign_enum() {
  default_foreign_enum_ = 5;
  clear_has_default_foreign_enum();
}
inline ::protobuf_unittest::ForeignEnum TestAllTypes::default_foreign_enum() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestAllTypes.default_foreign_enum)
  return static_cast< ::protobuf_unittest::ForeignEnum >(default_foreign_enum_);
}
inline void TestAllTypes::set_default_foreign_enum(::protobuf_unittest::ForeignEnum value) {
  assert(::protobuf_unittest::ForeignEnum_IsValid(value));
  set_has_default_foreign_enum();
  default_foreign_enum_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestAllTypes.default_foreign_enum)
}

// optional .protobuf_unittest_import.ImportEnum default_import_enum = 83 [default = IMPORT_BAR];
inline bool TestAllTypes::has_default_import_enum() const {
  return (_has_bits_[0] & 0x08000000u) != 0;
}
inline void TestAllTypes::set_has_default_import_enum() {
  _has_bits_[0] |= 0x08000000u;
}
inline void TestAllTypes::clear_has_default_import_enum() {
  _has_bits_[0] &= ~0x08000000u;
}
inline void TestAllTypes::clear_default_import_enum() {
  default_import_enum_ = 8;
  clear_has_default_import_enum();
}
inline ::protobuf_unittest_import::ImportEnum TestAllTypes::default_import_enum() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestAllTypes.default_import_enum)
  return static_cast< ::protobuf_unittest_import::ImportEnum >(default_import_enum_);
}
inline void TestAllTypes::set_default_import_enum(::protobuf_unittest_import::ImportEnum value) {
  assert(::protobuf_unittest_import::ImportEnum_IsValid(value));
  set_has_default_import_enum();
  default_import_enum_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestAllTypes.default_import_enum)
}

// optional string default_string_piece = 84 [default = "abc", ctype = STRING_PIECE];
inline bool TestAllTypes::has_default_string_piece() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void TestAllTypes::set_has_default_string_piece() {
  _has_bits_[0] |= 0x00000040u;
}
inline void TestAllTypes::clear_has_default_string_piece() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void TestAllTypes::clear_default_string_piece() {
  default_string_piece_.ClearToDefault(&::protobuf_unittest::TestAllTypes::_i_give_permission_to_break_this_code_default_default_string_piece_.get(), GetArenaNoVirtual());
  clear_has_default_string_piece();
}
inline const ::std::string& TestAllTypes::default_string_piece() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestAllTypes.default_string_piece)
  return default_string_piece_.Get();
}
inline void TestAllTypes::set_default_string_piece(const ::std::string& value) {
  set_has_default_string_piece();
  default_string_piece_.Set(&::protobuf_unittest::TestAllTypes::_i_give_permission_to_break_this_code_default_default_string_piece_.get(), value, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestAllTypes.default_string_piece)
}
#if LANG_CXX11
inline void TestAllTypes::set_default_string_piece(::std::string&& value) {
  set_has_default_string_piece();
  default_string_piece_.Set(
    &::protobuf_unittest::TestAllTypes::_i_give_permission_to_break_this_code_default_default_string_piece_.get(), ::std::move(value), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_rvalue:protobuf_unittest.TestAllTypes.default_string_piece)
}
#endif
inline void TestAllTypes::set_default_string_piece(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_default_string_piece();
  default_string_piece_.Set(&::protobuf_unittest::TestAllTypes::_i_give_permission_to_break_this_code_default_default_string_piece_.get(), ::std::string(value),
              GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_char:protobuf_unittest.TestAllTypes.default_string_piece)
}
inline void TestAllTypes::set_default_string_piece(const char* value,
    size_t size) {
  set_has_default_string_piece();
  default_string_piece_.Set(&::protobuf_unittest::TestAllTypes::_i_give_permission_to_break_this_code_default_default_string_piece_.get(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_pointer:protobuf_unittest.TestAllTypes.default_string_piece)
}
inline ::std::string* TestAllTypes::mutable_default_string_piece() {
  set_has_default_string_piece();
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestAllTypes.default_string_piece)
  return default_string_piece_.Mutable(&::protobuf_unittest::TestAllTypes::_i_give_permission_to_break_this_code_default_default_string_piece_.get(), GetArenaNoVirtual());
}
inline ::std::string* TestAllTypes::release_default_string_piece() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestAllTypes.default_string_piece)
  if (!has_default_string_piece()) {
    return NULL;
  }
  clear_has_default_string_piece();
  return default_string_piece_.ReleaseNonDefault(&::protobuf_unittest::TestAllTypes::_i_give_permission_to_break_this_code_default_default_string_piece_.get(), GetArenaNoVirtual());
}
inline void TestAllTypes::set_allocated_default_string_piece(::std::string* default_string_piece) {
  if (default_string_piece != NULL) {
    set_has_default_string_piece();
  } else {
    clear_has_default_string_piece();
  }
  default_string_piece_.SetAllocated(&::protobuf_unittest::TestAllTypes::_i_give_permission_to_break_this_code_default_default_string_piece_.get(), default_string_piece,
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestAllTypes.default_string_piece)
}
inline ::std::string* TestAllTypes::unsafe_arena_release_default_string_piece() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestAllTypes.default_string_piece)
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  clear_has_default_string_piece();
  return default_string_piece_.UnsafeArenaRelease(&::protobuf_unittest::TestAllTypes::_i_give_permission_to_break_this_code_default_default_string_piece_.get(),
      GetArenaNoVirtual());
}
inline void TestAllTypes::unsafe_arena_set_allocated_default_string_piece(
    ::std::string* default_string_piece) {
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (default_string_piece != NULL) {
    set_has_default_string_piece();
  } else {
    clear_has_default_string_piece();
  }
  default_string_piece_.UnsafeArenaSetAllocated(&::protobuf_unittest::TestAllTypes::_i_give_permission_to_break_this_code_default_default_string_piece_.get(),
      default_string_piece, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf_unittest.TestAllTypes.default_string_piece)
}

// optional string default_cord = 85 [default = "123", ctype = CORD];
inline bool TestAllTypes::has_default_cord() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void TestAllTypes::set_has_default_cord() {
  _has_bits_[0] |= 0x00000080u;
}
inline void TestAllTypes::clear_has_default_cord() {
  _has_bits_[0] &= ~0x00000080u;
}
inline void TestAllTypes::clear_default_cord() {
  default_cord_.ClearToDefault(&::protobuf_unittest::TestAllTypes::_i_give_permission_to_break_this_code_default_default_cord_.get(), GetArenaNoVirtual());
  clear_has_default_cord();
}
inline const ::std::string& TestAllTypes::default_cord() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestAllTypes.default_cord)
  return default_cord_.Get();
}
inline void TestAllTypes::set_default_cord(const ::std::string& value) {
  set_has_default_cord();
  default_cord_.Set(&::protobuf_unittest::TestAllTypes::_i_give_permission_to_break_this_code_default_default_cord_.get(), value, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestAllTypes.default_cord)
}
#if LANG_CXX11
inline void TestAllTypes::set_default_cord(::std::string&& value) {
  set_has_default_cord();
  default_cord_.Set(
    &::protobuf_unittest::TestAllTypes::_i_give_permission_to_break_this_code_default_default_cord_.get(), ::std::move(value), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_rvalue:protobuf_unittest.TestAllTypes.default_cord)
}
#endif
inline void TestAllTypes::set_default_cord(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_default_cord();
  default_cord_.Set(&::protobuf_unittest::TestAllTypes::_i_give_permission_to_break_this_code_default_default_cord_.get(), ::std::string(value),
              GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_char:protobuf_unittest.TestAllTypes.default_cord)
}
inline void TestAllTypes::set_default_cord(const char* value,
    size_t size) {
  set_has_default_cord();
  default_cord_.Set(&::protobuf_unittest::TestAllTypes::_i_give_permission_to_break_this_code_default_default_cord_.get(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_pointer:protobuf_unittest.TestAllTypes.default_cord)
}
inline ::std::string* TestAllTypes::mutable_default_cord() {
  set_has_default_cord();
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestAllTypes.default_cord)
  return default_cord_.Mutable(&::protobuf_unittest::TestAllTypes::_i_give_permission_to_break_this_code_default_default_cord_.get(), GetArenaNoVirtual());
}
inline ::std::string* TestAllTypes::release_default_cord() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestAllTypes.default_cord)
  if (!has_default_cord()) {
    return NULL;
  }
  clear_has_default_cord();
  return default_cord_.ReleaseNonDefault(&::protobuf_unittest::TestAllTypes::_i_give_permission_to_break_this_code_default_default_cord_.get(), GetArenaNoVirtual());
}
inline void TestAllTypes::set_allocated_default_cord(::std::string* default_cord) {
  if (default_cord != NULL) {
    set_has_default_cord();
  } else {
    clear_has_default_cord();
  }
  default_cord_.SetAllocated(&::protobuf_unittest::TestAllTypes::_i_give_permission_to_break_this_code_default_default_cord_.get(), default_cord,
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestAllTypes.default_cord)
}
inline ::std::string* TestAllTypes::unsafe_arena_release_default_cord() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestAllTypes.default_cord)
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  clear_has_default_cord();
  return default_cord_.UnsafeArenaRelease(&::protobuf_unittest::TestAllTypes::_i_give_permission_to_break_this_code_default_default_cord_.get(),
      GetArenaNoVirtual());
}
inline void TestAllTypes::unsafe_arena_set_allocated_default_cord(
    ::std::string* default_cord) {
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (default_cord != NULL) {
    set_has_default_cord();
  } else {
    clear_has_default_cord();
  }
  default_cord_.UnsafeArenaSetAllocated(&::protobuf_unittest::TestAllTypes::_i_give_permission_to_break_this_code_default_default_cord_.get(),
      default_cord, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf_unittest.TestAllTypes.default_cord)
}

// optional uint32 oneof_uint32 = 111;
inline bool TestAllTypes::has_oneof_uint32() const {
  return oneof_field_case() == kOneofUint32;
}
inline void TestAllTypes::set_has_oneof_uint32() {
  _oneof_case_[0] = kOneofUint32;
}
inline void TestAllTypes::clear_oneof_uint32() {
  if (has_oneof_uint32()) {
    oneof_field_.oneof_uint32_ = 0u;
    clear_has_oneof_field();
  }
}
inline ::google::protobuf::uint32 TestAllTypes::oneof_uint32() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestAllTypes.oneof_uint32)
  if (has_oneof_uint32()) {
    return oneof_field_.oneof_uint32_;
  }
  return 0u;
}
inline void TestAllTypes::set_oneof_uint32(::google::protobuf::uint32 value) {
  if (!has_oneof_uint32()) {
    clear_oneof_field();
    set_has_oneof_uint32();
  }
  oneof_field_.oneof_uint32_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestAllTypes.oneof_uint32)
}

// optional .protobuf_unittest.TestAllTypes.NestedMessage oneof_nested_message = 112;
inline bool TestAllTypes::has_oneof_nested_message() const {
  return oneof_field_case() == kOneofNestedMessage;
}
inline void TestAllTypes::set_has_oneof_nested_message() {
  _oneof_case_[0] = kOneofNestedMessage;
}
inline void TestAllTypes::clear_oneof_nested_message() {
  if (has_oneof_nested_message()) {
    if (GetArenaNoVirtual() == NULL) {
      delete oneof_field_.oneof_nested_message_;
    }
    clear_has_oneof_field();
  }
}
inline const ::protobuf_unittest::TestAllTypes_NestedMessage& TestAllTypes::_internal_oneof_nested_message() const {
  return *oneof_field_.oneof_nested_message_;
}
inline ::protobuf_unittest::TestAllTypes_NestedMessage* TestAllTypes::release_oneof_nested_message() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestAllTypes.oneof_nested_message)
  if (has_oneof_nested_message()) {
    clear_has_oneof_field();
      ::protobuf_unittest::TestAllTypes_NestedMessage* temp = oneof_field_.oneof_nested_message_;
    if (GetArenaNoVirtual() != NULL) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    oneof_field_.oneof_nested_message_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::protobuf_unittest::TestAllTypes_NestedMessage& TestAllTypes::oneof_nested_message() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestAllTypes.oneof_nested_message)
  return has_oneof_nested_message()
      ? *oneof_field_.oneof_nested_message_
      : *reinterpret_cast< ::protobuf_unittest::TestAllTypes_NestedMessage*>(&::protobuf_unittest::_TestAllTypes_NestedMessage_default_instance_);
}
inline ::protobuf_unittest::TestAllTypes_NestedMessage* TestAllTypes::unsafe_arena_release_oneof_nested_message() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestAllTypes.oneof_nested_message)
  if (has_oneof_nested_message()) {
    clear_has_oneof_field();
    ::protobuf_unittest::TestAllTypes_NestedMessage* temp = oneof_field_.oneof_nested_message_;
    oneof_field_.oneof_nested_message_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline void TestAllTypes::unsafe_arena_set_allocated_oneof_nested_message(::protobuf_unittest::TestAllTypes_NestedMessage* oneof_nested_message) {
  clear_oneof_field();
  if (oneof_nested_message) {
    set_has_oneof_nested_message();
    oneof_field_.oneof_nested_message_ = oneof_nested_message;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf_unittest.TestAllTypes.oneof_nested_message)
}
inline ::protobuf_unittest::TestAllTypes_NestedMessage* TestAllTypes::mutable_oneof_nested_message() {
  if (!has_oneof_nested_message()) {
    clear_oneof_field();
    set_has_oneof_nested_message();
    oneof_field_.oneof_nested_message_ = CreateMaybeMessage< ::protobuf_unittest::TestAllTypes_NestedMessage >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestAllTypes.oneof_nested_message)
  return oneof_field_.oneof_nested_message_;
}

// optional string oneof_string = 113;
inline bool TestAllTypes::has_oneof_string() const {
  return oneof_field_case() == kOneofString;
}
inline void TestAllTypes::set_has_oneof_string() {
  _oneof_case_[0] = kOneofString;
}
inline void TestAllTypes::clear_oneof_string() {
  if (has_oneof_string()) {
    oneof_field_.oneof_string_.Destroy(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
        GetArenaNoVirtual());
    clear_has_oneof_field();
  }
}
inline const ::std::string& TestAllTypes::oneof_string() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestAllTypes.oneof_string)
  if (has_oneof_string()) {
    return oneof_field_.oneof_string_.Get();
  }
  return *&::google::protobuf::internal::GetEmptyStringAlreadyInited();
}
inline void TestAllTypes::set_oneof_string(const ::std::string& value) {
  if (!has_oneof_string()) {
    clear_oneof_field();
    set_has_oneof_string();
    oneof_field_.oneof_string_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  oneof_field_.oneof_string_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value,
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestAllTypes.oneof_string)
}
#if LANG_CXX11
inline void TestAllTypes::set_oneof_string(::std::string&& value) {
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestAllTypes.oneof_string)
  if (!has_oneof_string()) {
    clear_oneof_field();
    set_has_oneof_string();
    oneof_field_.oneof_string_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  oneof_field_.oneof_string_.Set(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_rvalue:protobuf_unittest.TestAllTypes.oneof_string)
}
#endif
inline void TestAllTypes::set_oneof_string(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  if (!has_oneof_string()) {
    clear_oneof_field();
    set_has_oneof_string();
    oneof_field_.oneof_string_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  oneof_field_.oneof_string_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(value), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_char:protobuf_unittest.TestAllTypes.oneof_string)
}
inline void TestAllTypes::set_oneof_string(const char* value,
                             size_t size) {
  if (!has_oneof_string()) {
    clear_oneof_field();
    set_has_oneof_string();
    oneof_field_.oneof_string_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  oneof_field_.oneof_string_.Set(
      &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size),
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_pointer:protobuf_unittest.TestAllTypes.oneof_string)
}
inline ::std::string* TestAllTypes::mutable_oneof_string() {
  if (!has_oneof_string()) {
    clear_oneof_field();
    set_has_oneof_string();
    oneof_field_.oneof_string_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  return oneof_field_.oneof_string_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestAllTypes.oneof_string)
}
inline ::std::string* TestAllTypes::release_oneof_string() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestAllTypes.oneof_string)
  if (has_oneof_string()) {
    clear_has_oneof_field();
    return oneof_field_.oneof_string_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
        GetArenaNoVirtual());
  } else {
    return NULL;
  }
}
inline void TestAllTypes::set_allocated_oneof_string(::std::string* oneof_string) {
  if (!has_oneof_string()) {
    oneof_field_.oneof_string_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  clear_oneof_field();
  if (oneof_string != NULL) {
    set_has_oneof_string();
    oneof_field_.oneof_string_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), oneof_string,
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestAllTypes.oneof_string)
}
inline ::std::string* TestAllTypes::unsafe_arena_release_oneof_string() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestAllTypes.oneof_string)
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (has_oneof_string()) {
    clear_has_oneof_field();
    return oneof_field_.oneof_string_.UnsafeArenaRelease(
        &::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
  } else {
    return NULL;
  }
}
inline void TestAllTypes::unsafe_arena_set_allocated_oneof_string(::std::string* oneof_string) {
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (!has_oneof_string()) {
    oneof_field_.oneof_string_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  clear_oneof_field();
  if (oneof_string) {
    set_has_oneof_string();
    oneof_field_.oneof_string_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), oneof_string, GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf_unittest.TestAllTypes.oneof_string)
}

// optional bytes oneof_bytes = 114;
inline bool TestAllTypes::has_oneof_bytes() const {
  return oneof_field_case() == kOneofBytes;
}
inline void TestAllTypes::set_has_oneof_bytes() {
  _oneof_case_[0] = kOneofBytes;
}
inline void TestAllTypes::clear_oneof_bytes() {
  if (has_oneof_bytes()) {
    oneof_field_.oneof_bytes_.Destroy(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
        GetArenaNoVirtual());
    clear_has_oneof_field();
  }
}
inline const ::std::string& TestAllTypes::oneof_bytes() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestAllTypes.oneof_bytes)
  if (has_oneof_bytes()) {
    return oneof_field_.oneof_bytes_.Get();
  }
  return *&::google::protobuf::internal::GetEmptyStringAlreadyInited();
}
inline void TestAllTypes::set_oneof_bytes(const ::std::string& value) {
  if (!has_oneof_bytes()) {
    clear_oneof_field();
    set_has_oneof_bytes();
    oneof_field_.oneof_bytes_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  oneof_field_.oneof_bytes_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value,
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestAllTypes.oneof_bytes)
}
#if LANG_CXX11
inline void TestAllTypes::set_oneof_bytes(::std::string&& value) {
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestAllTypes.oneof_bytes)
  if (!has_oneof_bytes()) {
    clear_oneof_field();
    set_has_oneof_bytes();
    oneof_field_.oneof_bytes_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  oneof_field_.oneof_bytes_.Set(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_rvalue:protobuf_unittest.TestAllTypes.oneof_bytes)
}
#endif
inline void TestAllTypes::set_oneof_bytes(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  if (!has_oneof_bytes()) {
    clear_oneof_field();
    set_has_oneof_bytes();
    oneof_field_.oneof_bytes_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  oneof_field_.oneof_bytes_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(value), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_char:protobuf_unittest.TestAllTypes.oneof_bytes)
}
inline void TestAllTypes::set_oneof_bytes(const void* value,
                             size_t size) {
  if (!has_oneof_bytes()) {
    clear_oneof_field();
    set_has_oneof_bytes();
    oneof_field_.oneof_bytes_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  oneof_field_.oneof_bytes_.Set(
      &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size),
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_pointer:protobuf_unittest.TestAllTypes.oneof_bytes)
}
inline ::std::string* TestAllTypes::mutable_oneof_bytes() {
  if (!has_oneof_bytes()) {
    clear_oneof_field();
    set_has_oneof_bytes();
    oneof_field_.oneof_bytes_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  return oneof_field_.oneof_bytes_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestAllTypes.oneof_bytes)
}
inline ::std::string* TestAllTypes::release_oneof_bytes() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestAllTypes.oneof_bytes)
  if (has_oneof_bytes()) {
    clear_has_oneof_field();
    return oneof_field_.oneof_bytes_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
        GetArenaNoVirtual());
  } else {
    return NULL;
  }
}
inline void TestAllTypes::set_allocated_oneof_bytes(::std::string* oneof_bytes) {
  if (!has_oneof_bytes()) {
    oneof_field_.oneof_bytes_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  clear_oneof_field();
  if (oneof_bytes != NULL) {
    set_has_oneof_bytes();
    oneof_field_.oneof_bytes_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), oneof_bytes,
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestAllTypes.oneof_bytes)
}
inline ::std::string* TestAllTypes::unsafe_arena_release_oneof_bytes() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestAllTypes.oneof_bytes)
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (has_oneof_bytes()) {
    clear_has_oneof_field();
    return oneof_field_.oneof_bytes_.UnsafeArenaRelease(
        &::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
  } else {
    return NULL;
  }
}
inline void TestAllTypes::unsafe_arena_set_allocated_oneof_bytes(::std::string* oneof_bytes) {
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (!has_oneof_bytes()) {
    oneof_field_.oneof_bytes_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  clear_oneof_field();
  if (oneof_bytes) {
    set_has_oneof_bytes();
    oneof_field_.oneof_bytes_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), oneof_bytes, GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf_unittest.TestAllTypes.oneof_bytes)
}

inline bool TestAllTypes::has_oneof_field() const {
  return oneof_field_case() != ONEOF_FIELD_NOT_SET;
}
inline void TestAllTypes::clear_has_oneof_field() {
  _oneof_case_[0] = ONEOF_FIELD_NOT_SET;
}
inline TestAllTypes::OneofFieldCase TestAllTypes::oneof_field_case() const {
  return TestAllTypes::OneofFieldCase(_oneof_case_[0]);
}
// -------------------------------------------------------------------

// NestedTestAllTypes

// optional .protobuf_unittest.NestedTestAllTypes child = 1;
inline bool NestedTestAllTypes::has_child() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void NestedTestAllTypes::set_has_child() {
  _has_bits_[0] |= 0x00000001u;
}
inline void NestedTestAllTypes::clear_has_child() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void NestedTestAllTypes::clear_child() {
  if (child_ != NULL) child_->Clear();
  clear_has_child();
}
inline const ::protobuf_unittest::NestedTestAllTypes& NestedTestAllTypes::_internal_child() const {
  return *child_;
}
inline const ::protobuf_unittest::NestedTestAllTypes& NestedTestAllTypes::child() const {
  const ::protobuf_unittest::NestedTestAllTypes* p = child_;
  // @@protoc_insertion_point(field_get:protobuf_unittest.NestedTestAllTypes.child)
  return p != NULL ? *p : *reinterpret_cast<const ::protobuf_unittest::NestedTestAllTypes*>(
      &::protobuf_unittest::_NestedTestAllTypes_default_instance_);
}
inline ::protobuf_unittest::NestedTestAllTypes* NestedTestAllTypes::release_child() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.NestedTestAllTypes.child)
  clear_has_child();
  ::protobuf_unittest::NestedTestAllTypes* temp = child_;
  if (GetArenaNoVirtual() != NULL) {
    temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
  }
  child_ = NULL;
  return temp;
}
inline ::protobuf_unittest::NestedTestAllTypes* NestedTestAllTypes::unsafe_arena_release_child() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.NestedTestAllTypes.child)
  clear_has_child();
  ::protobuf_unittest::NestedTestAllTypes* temp = child_;
  child_ = NULL;
  return temp;
}
inline ::protobuf_unittest::NestedTestAllTypes* NestedTestAllTypes::mutable_child() {
  set_has_child();
  if (child_ == NULL) {
    auto* p = CreateMaybeMessage<::protobuf_unittest::NestedTestAllTypes>(GetArenaNoVirtual());
    child_ = p;
  }
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.NestedTestAllTypes.child)
  return child_;
}
inline void NestedTestAllTypes::set_allocated_child(::protobuf_unittest::NestedTestAllTypes* child) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete child_;
  }
  if (child) {
    ::google::protobuf::Arena* submessage_arena =
      ::google::protobuf::Arena::GetArena(child);
    if (message_arena != submessage_arena) {
      child = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, child, submessage_arena);
    }
    set_has_child();
  } else {
    clear_has_child();
  }
  child_ = child;
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.NestedTestAllTypes.child)
}

// optional .protobuf_unittest.TestAllTypes payload = 2;
inline bool NestedTestAllTypes::has_payload() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void NestedTestAllTypes::set_has_payload() {
  _has_bits_[0] |= 0x00000002u;
}
inline void NestedTestAllTypes::clear_has_payload() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void NestedTestAllTypes::clear_payload() {
  if (payload_ != NULL) payload_->Clear();
  clear_has_payload();
}
inline const ::protobuf_unittest::TestAllTypes& NestedTestAllTypes::_internal_payload() const {
  return *payload_;
}
inline const ::protobuf_unittest::TestAllTypes& NestedTestAllTypes::payload() const {
  const ::protobuf_unittest::TestAllTypes* p = payload_;
  // @@protoc_insertion_point(field_get:protobuf_unittest.NestedTestAllTypes.payload)
  return p != NULL ? *p : *reinterpret_cast<const ::protobuf_unittest::TestAllTypes*>(
      &::protobuf_unittest::_TestAllTypes_default_instance_);
}
inline ::protobuf_unittest::TestAllTypes* NestedTestAllTypes::release_payload() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.NestedTestAllTypes.payload)
  clear_has_payload();
  ::protobuf_unittest::TestAllTypes* temp = payload_;
  if (GetArenaNoVirtual() != NULL) {
    temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
  }
  payload_ = NULL;
  return temp;
}
inline ::protobuf_unittest::TestAllTypes* NestedTestAllTypes::unsafe_arena_release_payload() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.NestedTestAllTypes.payload)
  clear_has_payload();
  ::protobuf_unittest::TestAllTypes* temp = payload_;
  payload_ = NULL;
  return temp;
}
inline ::protobuf_unittest::TestAllTypes* NestedTestAllTypes::mutable_payload() {
  set_has_payload();
  if (payload_ == NULL) {
    auto* p = CreateMaybeMessage<::protobuf_unittest::TestAllTypes>(GetArenaNoVirtual());
    payload_ = p;
  }
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.NestedTestAllTypes.payload)
  return payload_;
}
inline void NestedTestAllTypes::set_allocated_payload(::protobuf_unittest::TestAllTypes* payload) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete payload_;
  }
  if (payload) {
    ::google::protobuf::Arena* submessage_arena =
      ::google::protobuf::Arena::GetArena(payload);
    if (message_arena != submessage_arena) {
      payload = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, payload, submessage_arena);
    }
    set_has_payload();
  } else {
    clear_has_payload();
  }
  payload_ = payload;
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.NestedTestAllTypes.payload)
}

// repeated .protobuf_unittest.NestedTestAllTypes repeated_child = 3;
inline int NestedTestAllTypes::repeated_child_size() const {
  return repeated_child_.size();
}
inline void NestedTestAllTypes::clear_repeated_child() {
  repeated_child_.Clear();
}
inline ::protobuf_unittest::NestedTestAllTypes* NestedTestAllTypes::mutable_repeated_child(int index) {
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.NestedTestAllTypes.repeated_child)
  return repeated_child_.Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::NestedTestAllTypes >*
NestedTestAllTypes::mutable_repeated_child() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.NestedTestAllTypes.repeated_child)
  return &repeated_child_;
}
inline const ::protobuf_unittest::NestedTestAllTypes& NestedTestAllTypes::repeated_child(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.NestedTestAllTypes.repeated_child)
  return repeated_child_.Get(index);
}
inline ::protobuf_unittest::NestedTestAllTypes* NestedTestAllTypes::add_repeated_child() {
  // @@protoc_insertion_point(field_add:protobuf_unittest.NestedTestAllTypes.repeated_child)
  return repeated_child_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::NestedTestAllTypes >&
NestedTestAllTypes::repeated_child() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.NestedTestAllTypes.repeated_child)
  return repeated_child_;
}

// -------------------------------------------------------------------

// TestDeprecatedFields

// optional int32 deprecated_int32 = 1 [deprecated = true];
inline bool TestDeprecatedFields::has_deprecated_int32() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TestDeprecatedFields::set_has_deprecated_int32() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TestDeprecatedFields::clear_has_deprecated_int32() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TestDeprecatedFields::clear_deprecated_int32() {
  deprecated_int32_ = 0;
  clear_has_deprecated_int32();
}
inline ::google::protobuf::int32 TestDeprecatedFields::deprecated_int32() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestDeprecatedFields.deprecated_int32)
  return deprecated_int32_;
}
inline void TestDeprecatedFields::set_deprecated_int32(::google::protobuf::int32 value) {
  set_has_deprecated_int32();
  deprecated_int32_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestDeprecatedFields.deprecated_int32)
}

// optional int32 deprecated_int32_in_oneof = 2 [deprecated = true];
inline bool TestDeprecatedFields::has_deprecated_int32_in_oneof() const {
  return oneof_fields_case() == kDeprecatedInt32InOneof;
}
inline void TestDeprecatedFields::set_has_deprecated_int32_in_oneof() {
  _oneof_case_[0] = kDeprecatedInt32InOneof;
}
inline void TestDeprecatedFields::clear_deprecated_int32_in_oneof() {
  if (has_deprecated_int32_in_oneof()) {
    oneof_fields_.deprecated_int32_in_oneof_ = 0;
    clear_has_oneof_fields();
  }
}
inline ::google::protobuf::int32 TestDeprecatedFields::deprecated_int32_in_oneof() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestDeprecatedFields.deprecated_int32_in_oneof)
  if (has_deprecated_int32_in_oneof()) {
    return oneof_fields_.deprecated_int32_in_oneof_;
  }
  return 0;
}
inline void TestDeprecatedFields::set_deprecated_int32_in_oneof(::google::protobuf::int32 value) {
  if (!has_deprecated_int32_in_oneof()) {
    clear_oneof_fields();
    set_has_deprecated_int32_in_oneof();
  }
  oneof_fields_.deprecated_int32_in_oneof_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestDeprecatedFields.deprecated_int32_in_oneof)
}

inline bool TestDeprecatedFields::has_oneof_fields() const {
  return oneof_fields_case() != ONEOF_FIELDS_NOT_SET;
}
inline void TestDeprecatedFields::clear_has_oneof_fields() {
  _oneof_case_[0] = ONEOF_FIELDS_NOT_SET;
}
inline TestDeprecatedFields::OneofFieldsCase TestDeprecatedFields::oneof_fields_case() const {
  return TestDeprecatedFields::OneofFieldsCase(_oneof_case_[0]);
}
// -------------------------------------------------------------------

// TestDeprecatedMessage

// -------------------------------------------------------------------

// ForeignMessage

// optional int32 c = 1;
inline bool ForeignMessage::has_c() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ForeignMessage::set_has_c() {
  _has_bits_[0] |= 0x00000001u;
}
inline void ForeignMessage::clear_has_c() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void ForeignMessage::clear_c() {
  c_ = 0;
  clear_has_c();
}
inline ::google::protobuf::int32 ForeignMessage::c() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.ForeignMessage.c)
  return c_;
}
inline void ForeignMessage::set_c(::google::protobuf::int32 value) {
  set_has_c();
  c_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.ForeignMessage.c)
}

// optional int32 d = 2;
inline bool ForeignMessage::has_d() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ForeignMessage::set_has_d() {
  _has_bits_[0] |= 0x00000002u;
}
inline void ForeignMessage::clear_has_d() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void ForeignMessage::clear_d() {
  d_ = 0;
  clear_has_d();
}
inline ::google::protobuf::int32 ForeignMessage::d() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.ForeignMessage.d)
  return d_;
}
inline void ForeignMessage::set_d(::google::protobuf::int32 value) {
  set_has_d();
  d_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.ForeignMessage.d)
}

// -------------------------------------------------------------------

// TestReservedFields

// -------------------------------------------------------------------

// TestAllExtensions

// -------------------------------------------------------------------

// OptionalGroup_extension

// optional int32 a = 17;
inline bool OptionalGroup_extension::has_a() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void OptionalGroup_extension::set_has_a() {
  _has_bits_[0] |= 0x00000001u;
}
inline void OptionalGroup_extension::clear_has_a() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void OptionalGroup_extension::clear_a() {
  a_ = 0;
  clear_has_a();
}
inline ::google::protobuf::int32 OptionalGroup_extension::a() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.OptionalGroup_extension.a)
  return a_;
}
inline void OptionalGroup_extension::set_a(::google::protobuf::int32 value) {
  set_has_a();
  a_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.OptionalGroup_extension.a)
}

// -------------------------------------------------------------------

// RepeatedGroup_extension

// optional int32 a = 47;
inline bool RepeatedGroup_extension::has_a() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void RepeatedGroup_extension::set_has_a() {
  _has_bits_[0] |= 0x00000001u;
}
inline void RepeatedGroup_extension::clear_has_a() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void RepeatedGroup_extension::clear_a() {
  a_ = 0;
  clear_has_a();
}
inline ::google::protobuf::int32 RepeatedGroup_extension::a() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.RepeatedGroup_extension.a)
  return a_;
}
inline void RepeatedGroup_extension::set_a(::google::protobuf::int32 value) {
  set_has_a();
  a_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.RepeatedGroup_extension.a)
}

// -------------------------------------------------------------------

// TestGroup_OptionalGroup

// optional int32 a = 17;
inline bool TestGroup_OptionalGroup::has_a() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TestGroup_OptionalGroup::set_has_a() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TestGroup_OptionalGroup::clear_has_a() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TestGroup_OptionalGroup::clear_a() {
  a_ = 0;
  clear_has_a();
}
inline ::google::protobuf::int32 TestGroup_OptionalGroup::a() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestGroup.OptionalGroup.a)
  return a_;
}
inline void TestGroup_OptionalGroup::set_a(::google::protobuf::int32 value) {
  set_has_a();
  a_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestGroup.OptionalGroup.a)
}

// -------------------------------------------------------------------

// TestGroup

// optional group OptionalGroup = 16 { ... };
inline bool TestGroup::has_optionalgroup() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TestGroup::set_has_optionalgroup() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TestGroup::clear_has_optionalgroup() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TestGroup::clear_optionalgroup() {
  if (optionalgroup_ != NULL) optionalgroup_->Clear();
  clear_has_optionalgroup();
}
inline const ::protobuf_unittest::TestGroup_OptionalGroup& TestGroup::_internal_optionalgroup() const {
  return *optionalgroup_;
}
inline const ::protobuf_unittest::TestGroup_OptionalGroup& TestGroup::optionalgroup() const {
  const ::protobuf_unittest::TestGroup_OptionalGroup* p = optionalgroup_;
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestGroup.optionalgroup)
  return p != NULL ? *p : *reinterpret_cast<const ::protobuf_unittest::TestGroup_OptionalGroup*>(
      &::protobuf_unittest::_TestGroup_OptionalGroup_default_instance_);
}
inline ::protobuf_unittest::TestGroup_OptionalGroup* TestGroup::release_optionalgroup() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestGroup.optionalgroup)
  clear_has_optionalgroup();
  ::protobuf_unittest::TestGroup_OptionalGroup* temp = optionalgroup_;
  if (GetArenaNoVirtual() != NULL) {
    temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
  }
  optionalgroup_ = NULL;
  return temp;
}
inline ::protobuf_unittest::TestGroup_OptionalGroup* TestGroup::unsafe_arena_release_optionalgroup() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestGroup.optionalgroup)
  clear_has_optionalgroup();
  ::protobuf_unittest::TestGroup_OptionalGroup* temp = optionalgroup_;
  optionalgroup_ = NULL;
  return temp;
}
inline ::protobuf_unittest::TestGroup_OptionalGroup* TestGroup::mutable_optionalgroup() {
  set_has_optionalgroup();
  if (optionalgroup_ == NULL) {
    auto* p = CreateMaybeMessage<::protobuf_unittest::TestGroup_OptionalGroup>(GetArenaNoVirtual());
    optionalgroup_ = p;
  }
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestGroup.optionalgroup)
  return optionalgroup_;
}
inline void TestGroup::set_allocated_optionalgroup(::protobuf_unittest::TestGroup_OptionalGroup* optionalgroup) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete optionalgroup_;
  }
  if (optionalgroup) {
    ::google::protobuf::Arena* submessage_arena =
      ::google::protobuf::Arena::GetArena(optionalgroup);
    if (message_arena != submessage_arena) {
      optionalgroup = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, optionalgroup, submessage_arena);
    }
    set_has_optionalgroup();
  } else {
    clear_has_optionalgroup();
  }
  optionalgroup_ = optionalgroup;
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestGroup.optionalgroup)
}

// optional .protobuf_unittest.ForeignEnum optional_foreign_enum = 22;
inline bool TestGroup::has_optional_foreign_enum() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void TestGroup::set_has_optional_foreign_enum() {
  _has_bits_[0] |= 0x00000002u;
}
inline void TestGroup::clear_has_optional_foreign_enum() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void TestGroup::clear_optional_foreign_enum() {
  optional_foreign_enum_ = 4;
  clear_has_optional_foreign_enum();
}
inline ::protobuf_unittest::ForeignEnum TestGroup::optional_foreign_enum() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestGroup.optional_foreign_enum)
  return static_cast< ::protobuf_unittest::ForeignEnum >(optional_foreign_enum_);
}
inline void TestGroup::set_optional_foreign_enum(::protobuf_unittest::ForeignEnum value) {
  assert(::protobuf_unittest::ForeignEnum_IsValid(value));
  set_has_optional_foreign_enum();
  optional_foreign_enum_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestGroup.optional_foreign_enum)
}

// -------------------------------------------------------------------

// TestGroupExtension

// -------------------------------------------------------------------

// TestNestedExtension_OptionalGroup_extension

// optional int32 a = 17;
inline bool TestNestedExtension_OptionalGroup_extension::has_a() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TestNestedExtension_OptionalGroup_extension::set_has_a() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TestNestedExtension_OptionalGroup_extension::clear_has_a() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TestNestedExtension_OptionalGroup_extension::clear_a() {
  a_ = 0;
  clear_has_a();
}
inline ::google::protobuf::int32 TestNestedExtension_OptionalGroup_extension::a() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestNestedExtension.OptionalGroup_extension.a)
  return a_;
}
inline void TestNestedExtension_OptionalGroup_extension::set_a(::google::protobuf::int32 value) {
  set_has_a();
  a_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestNestedExtension.OptionalGroup_extension.a)
}

// -------------------------------------------------------------------

// TestNestedExtension

// -------------------------------------------------------------------

// TestRequired

// required int32 a = 1;
inline bool TestRequired::has_a() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TestRequired::set_has_a() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TestRequired::clear_has_a() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TestRequired::clear_a() {
  a_ = 0;
  clear_has_a();
}
inline ::google::protobuf::int32 TestRequired::a() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestRequired.a)
  return a_;
}
inline void TestRequired::set_a(::google::protobuf::int32 value) {
  set_has_a();
  a_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestRequired.a)
}

// optional int32 dummy2 = 2;
inline bool TestRequired::has_dummy2() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void TestRequired::set_has_dummy2() {
  _has_bits_[0] |= 0x00000002u;
}
inline void TestRequired::clear_has_dummy2() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void TestRequired::clear_dummy2() {
  dummy2_ = 0;
  clear_has_dummy2();
}
inline ::google::protobuf::int32 TestRequired::dummy2() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestRequired.dummy2)
  return dummy2_;
}
inline void TestRequired::set_dummy2(::google::protobuf::int32 value) {
  set_has_dummy2();
  dummy2_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestRequired.dummy2)
}

// required int32 b = 3;
inline bool TestRequired::has_b() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void TestRequired::set_has_b() {
  _has_bits_[0] |= 0x00000004u;
}
inline void TestRequired::clear_has_b() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void TestRequired::clear_b() {
  b_ = 0;
  clear_has_b();
}
inline ::google::protobuf::int32 TestRequired::b() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestRequired.b)
  return b_;
}
inline void TestRequired::set_b(::google::protobuf::int32 value) {
  set_has_b();
  b_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestRequired.b)
}

// optional int32 dummy4 = 4;
inline bool TestRequired::has_dummy4() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void TestRequired::set_has_dummy4() {
  _has_bits_[0] |= 0x00000008u;
}
inline void TestRequired::clear_has_dummy4() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void TestRequired::clear_dummy4() {
  dummy4_ = 0;
  clear_has_dummy4();
}
inline ::google::protobuf::int32 TestRequired::dummy4() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestRequired.dummy4)
  return dummy4_;
}
inline void TestRequired::set_dummy4(::google::protobuf::int32 value) {
  set_has_dummy4();
  dummy4_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestRequired.dummy4)
}

// optional int32 dummy5 = 5;
inline bool TestRequired::has_dummy5() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void TestRequired::set_has_dummy5() {
  _has_bits_[0] |= 0x00000010u;
}
inline void TestRequired::clear_has_dummy5() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void TestRequired::clear_dummy5() {
  dummy5_ = 0;
  clear_has_dummy5();
}
inline ::google::protobuf::int32 TestRequired::dummy5() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestRequired.dummy5)
  return dummy5_;
}
inline void TestRequired::set_dummy5(::google::protobuf::int32 value) {
  set_has_dummy5();
  dummy5_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestRequired.dummy5)
}

// optional int32 dummy6 = 6;
inline bool TestRequired::has_dummy6() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void TestRequired::set_has_dummy6() {
  _has_bits_[0] |= 0x00000020u;
}
inline void TestRequired::clear_has_dummy6() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void TestRequired::clear_dummy6() {
  dummy6_ = 0;
  clear_has_dummy6();
}
inline ::google::protobuf::int32 TestRequired::dummy6() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestRequired.dummy6)
  return dummy6_;
}
inline void TestRequired::set_dummy6(::google::protobuf::int32 value) {
  set_has_dummy6();
  dummy6_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestRequired.dummy6)
}

// optional int32 dummy7 = 7;
inline bool TestRequired::has_dummy7() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void TestRequired::set_has_dummy7() {
  _has_bits_[0] |= 0x00000040u;
}
inline void TestRequired::clear_has_dummy7() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void TestRequired::clear_dummy7() {
  dummy7_ = 0;
  clear_has_dummy7();
}
inline ::google::protobuf::int32 TestRequired::dummy7() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestRequired.dummy7)
  return dummy7_;
}
inline void TestRequired::set_dummy7(::google::protobuf::int32 value) {
  set_has_dummy7();
  dummy7_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestRequired.dummy7)
}

// optional int32 dummy8 = 8;
inline bool TestRequired::has_dummy8() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void TestRequired::set_has_dummy8() {
  _has_bits_[0] |= 0x00000080u;
}
inline void TestRequired::clear_has_dummy8() {
  _has_bits_[0] &= ~0x00000080u;
}
inline void TestRequired::clear_dummy8() {
  dummy8_ = 0;
  clear_has_dummy8();
}
inline ::google::protobuf::int32 TestRequired::dummy8() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestRequired.dummy8)
  return dummy8_;
}
inline void TestRequired::set_dummy8(::google::protobuf::int32 value) {
  set_has_dummy8();
  dummy8_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestRequired.dummy8)
}

// optional int32 dummy9 = 9;
inline bool TestRequired::has_dummy9() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void TestRequired::set_has_dummy9() {
  _has_bits_[0] |= 0x00000100u;
}
inline void TestRequired::clear_has_dummy9() {
  _has_bits_[0] &= ~0x00000100u;
}
inline void TestRequired::clear_dummy9() {
  dummy9_ = 0;
  clear_has_dummy9();
}
inline ::google::protobuf::int32 TestRequired::dummy9() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestRequired.dummy9)
  return dummy9_;
}
inline void TestRequired::set_dummy9(::google::protobuf::int32 value) {
  set_has_dummy9();
  dummy9_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestRequired.dummy9)
}

// optional int32 dummy10 = 10;
inline bool TestRequired::has_dummy10() const {
  return (_has_bits_[0] & 0x00000200u) != 0;
}
inline void TestRequired::set_has_dummy10() {
  _has_bits_[0] |= 0x00000200u;
}
inline void TestRequired::clear_has_dummy10() {
  _has_bits_[0] &= ~0x00000200u;
}
inline void TestRequired::clear_dummy10() {
  dummy10_ = 0;
  clear_has_dummy10();
}
inline ::google::protobuf::int32 TestRequired::dummy10() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestRequired.dummy10)
  return dummy10_;
}
inline void TestRequired::set_dummy10(::google::protobuf::int32 value) {
  set_has_dummy10();
  dummy10_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestRequired.dummy10)
}

// optional int32 dummy11 = 11;
inline bool TestRequired::has_dummy11() const {
  return (_has_bits_[0] & 0x00000400u) != 0;
}
inline void TestRequired::set_has_dummy11() {
  _has_bits_[0] |= 0x00000400u;
}
inline void TestRequired::clear_has_dummy11() {
  _has_bits_[0] &= ~0x00000400u;
}
inline void TestRequired::clear_dummy11() {
  dummy11_ = 0;
  clear_has_dummy11();
}
inline ::google::protobuf::int32 TestRequired::dummy11() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestRequired.dummy11)
  return dummy11_;
}
inline void TestRequired::set_dummy11(::google::protobuf::int32 value) {
  set_has_dummy11();
  dummy11_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestRequired.dummy11)
}

// optional int32 dummy12 = 12;
inline bool TestRequired::has_dummy12() const {
  return (_has_bits_[0] & 0x00000800u) != 0;
}
inline void TestRequired::set_has_dummy12() {
  _has_bits_[0] |= 0x00000800u;
}
inline void TestRequired::clear_has_dummy12() {
  _has_bits_[0] &= ~0x00000800u;
}
inline void TestRequired::clear_dummy12() {
  dummy12_ = 0;
  clear_has_dummy12();
}
inline ::google::protobuf::int32 TestRequired::dummy12() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestRequired.dummy12)
  return dummy12_;
}
inline void TestRequired::set_dummy12(::google::protobuf::int32 value) {
  set_has_dummy12();
  dummy12_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestRequired.dummy12)
}

// optional int32 dummy13 = 13;
inline bool TestRequired::has_dummy13() const {
  return (_has_bits_[0] & 0x00001000u) != 0;
}
inline void TestRequired::set_has_dummy13() {
  _has_bits_[0] |= 0x00001000u;
}
inline void TestRequired::clear_has_dummy13() {
  _has_bits_[0] &= ~0x00001000u;
}
inline void TestRequired::clear_dummy13() {
  dummy13_ = 0;
  clear_has_dummy13();
}
inline ::google::protobuf::int32 TestRequired::dummy13() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestRequired.dummy13)
  return dummy13_;
}
inline void TestRequired::set_dummy13(::google::protobuf::int32 value) {
  set_has_dummy13();
  dummy13_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestRequired.dummy13)
}

// optional int32 dummy14 = 14;
inline bool TestRequired::has_dummy14() const {
  return (_has_bits_[0] & 0x00002000u) != 0;
}
inline void TestRequired::set_has_dummy14() {
  _has_bits_[0] |= 0x00002000u;
}
inline void TestRequired::clear_has_dummy14() {
  _has_bits_[0] &= ~0x00002000u;
}
inline void TestRequired::clear_dummy14() {
  dummy14_ = 0;
  clear_has_dummy14();
}
inline ::google::protobuf::int32 TestRequired::dummy14() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestRequired.dummy14)
  return dummy14_;
}
inline void TestRequired::set_dummy14(::google::protobuf::int32 value) {
  set_has_dummy14();
  dummy14_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestRequired.dummy14)
}

// optional int32 dummy15 = 15;
inline bool TestRequired::has_dummy15() const {
  return (_has_bits_[0] & 0x00004000u) != 0;
}
inline void TestRequired::set_has_dummy15() {
  _has_bits_[0] |= 0x00004000u;
}
inline void TestRequired::clear_has_dummy15() {
  _has_bits_[0] &= ~0x00004000u;
}
inline void TestRequired::clear_dummy15() {
  dummy15_ = 0;
  clear_has_dummy15();
}
inline ::google::protobuf::int32 TestRequired::dummy15() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestRequired.dummy15)
  return dummy15_;
}
inline void TestRequired::set_dummy15(::google::protobuf::int32 value) {
  set_has_dummy15();
  dummy15_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestRequired.dummy15)
}

// optional int32 dummy16 = 16;
inline bool TestRequired::has_dummy16() const {
  return (_has_bits_[0] & 0x00008000u) != 0;
}
inline void TestRequired::set_has_dummy16() {
  _has_bits_[0] |= 0x00008000u;
}
inline void TestRequired::clear_has_dummy16() {
  _has_bits_[0] &= ~0x00008000u;
}
inline void TestRequired::clear_dummy16() {
  dummy16_ = 0;
  clear_has_dummy16();
}
inline ::google::protobuf::int32 TestRequired::dummy16() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestRequired.dummy16)
  return dummy16_;
}
inline void TestRequired::set_dummy16(::google::protobuf::int32 value) {
  set_has_dummy16();
  dummy16_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestRequired.dummy16)
}

// optional int32 dummy17 = 17;
inline bool TestRequired::has_dummy17() const {
  return (_has_bits_[0] & 0x00010000u) != 0;
}
inline void TestRequired::set_has_dummy17() {
  _has_bits_[0] |= 0x00010000u;
}
inline void TestRequired::clear_has_dummy17() {
  _has_bits_[0] &= ~0x00010000u;
}
inline void TestRequired::clear_dummy17() {
  dummy17_ = 0;
  clear_has_dummy17();
}
inline ::google::protobuf::int32 TestRequired::dummy17() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestRequired.dummy17)
  return dummy17_;
}
inline void TestRequired::set_dummy17(::google::protobuf::int32 value) {
  set_has_dummy17();
  dummy17_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestRequired.dummy17)
}

// optional int32 dummy18 = 18;
inline bool TestRequired::has_dummy18() const {
  return (_has_bits_[0] & 0x00020000u) != 0;
}
inline void TestRequired::set_has_dummy18() {
  _has_bits_[0] |= 0x00020000u;
}
inline void TestRequired::clear_has_dummy18() {
  _has_bits_[0] &= ~0x00020000u;
}
inline void TestRequired::clear_dummy18() {
  dummy18_ = 0;
  clear_has_dummy18();
}
inline ::google::protobuf::int32 TestRequired::dummy18() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestRequired.dummy18)
  return dummy18_;
}
inline void TestRequired::set_dummy18(::google::protobuf::int32 value) {
  set_has_dummy18();
  dummy18_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestRequired.dummy18)
}

// optional int32 dummy19 = 19;
inline bool TestRequired::has_dummy19() const {
  return (_has_bits_[0] & 0x00040000u) != 0;
}
inline void TestRequired::set_has_dummy19() {
  _has_bits_[0] |= 0x00040000u;
}
inline void TestRequired::clear_has_dummy19() {
  _has_bits_[0] &= ~0x00040000u;
}
inline void TestRequired::clear_dummy19() {
  dummy19_ = 0;
  clear_has_dummy19();
}
inline ::google::protobuf::int32 TestRequired::dummy19() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestRequired.dummy19)
  return dummy19_;
}
inline void TestRequired::set_dummy19(::google::protobuf::int32 value) {
  set_has_dummy19();
  dummy19_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestRequired.dummy19)
}

// optional int32 dummy20 = 20;
inline bool TestRequired::has_dummy20() const {
  return (_has_bits_[0] & 0x00080000u) != 0;
}
inline void TestRequired::set_has_dummy20() {
  _has_bits_[0] |= 0x00080000u;
}
inline void TestRequired::clear_has_dummy20() {
  _has_bits_[0] &= ~0x00080000u;
}
inline void TestRequired::clear_dummy20() {
  dummy20_ = 0;
  clear_has_dummy20();
}
inline ::google::protobuf::int32 TestRequired::dummy20() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestRequired.dummy20)
  return dummy20_;
}
inline void TestRequired::set_dummy20(::google::protobuf::int32 value) {
  set_has_dummy20();
  dummy20_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestRequired.dummy20)
}

// optional int32 dummy21 = 21;
inline bool TestRequired::has_dummy21() const {
  return (_has_bits_[0] & 0x00100000u) != 0;
}
inline void TestRequired::set_has_dummy21() {
  _has_bits_[0] |= 0x00100000u;
}
inline void TestRequired::clear_has_dummy21() {
  _has_bits_[0] &= ~0x00100000u;
}
inline void TestRequired::clear_dummy21() {
  dummy21_ = 0;
  clear_has_dummy21();
}
inline ::google::protobuf::int32 TestRequired::dummy21() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestRequired.dummy21)
  return dummy21_;
}
inline void TestRequired::set_dummy21(::google::protobuf::int32 value) {
  set_has_dummy21();
  dummy21_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestRequired.dummy21)
}

// optional int32 dummy22 = 22;
inline bool TestRequired::has_dummy22() const {
  return (_has_bits_[0] & 0x00200000u) != 0;
}
inline void TestRequired::set_has_dummy22() {
  _has_bits_[0] |= 0x00200000u;
}
inline void TestRequired::clear_has_dummy22() {
  _has_bits_[0] &= ~0x00200000u;
}
inline void TestRequired::clear_dummy22() {
  dummy22_ = 0;
  clear_has_dummy22();
}
inline ::google::protobuf::int32 TestRequired::dummy22() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestRequired.dummy22)
  return dummy22_;
}
inline void TestRequired::set_dummy22(::google::protobuf::int32 value) {
  set_has_dummy22();
  dummy22_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestRequired.dummy22)
}

// optional int32 dummy23 = 23;
inline bool TestRequired::has_dummy23() const {
  return (_has_bits_[0] & 0x00400000u) != 0;
}
inline void TestRequired::set_has_dummy23() {
  _has_bits_[0] |= 0x00400000u;
}
inline void TestRequired::clear_has_dummy23() {
  _has_bits_[0] &= ~0x00400000u;
}
inline void TestRequired::clear_dummy23() {
  dummy23_ = 0;
  clear_has_dummy23();
}
inline ::google::protobuf::int32 TestRequired::dummy23() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestRequired.dummy23)
  return dummy23_;
}
inline void TestRequired::set_dummy23(::google::protobuf::int32 value) {
  set_has_dummy23();
  dummy23_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestRequired.dummy23)
}

// optional int32 dummy24 = 24;
inline bool TestRequired::has_dummy24() const {
  return (_has_bits_[0] & 0x00800000u) != 0;
}
inline void TestRequired::set_has_dummy24() {
  _has_bits_[0] |= 0x00800000u;
}
inline void TestRequired::clear_has_dummy24() {
  _has_bits_[0] &= ~0x00800000u;
}
inline void TestRequired::clear_dummy24() {
  dummy24_ = 0;
  clear_has_dummy24();
}
inline ::google::protobuf::int32 TestRequired::dummy24() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestRequired.dummy24)
  return dummy24_;
}
inline void TestRequired::set_dummy24(::google::protobuf::int32 value) {
  set_has_dummy24();
  dummy24_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestRequired.dummy24)
}

// optional int32 dummy25 = 25;
inline bool TestRequired::has_dummy25() const {
  return (_has_bits_[0] & 0x01000000u) != 0;
}
inline void TestRequired::set_has_dummy25() {
  _has_bits_[0] |= 0x01000000u;
}
inline void TestRequired::clear_has_dummy25() {
  _has_bits_[0] &= ~0x01000000u;
}
inline void TestRequired::clear_dummy25() {
  dummy25_ = 0;
  clear_has_dummy25();
}
inline ::google::protobuf::int32 TestRequired::dummy25() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestRequired.dummy25)
  return dummy25_;
}
inline void TestRequired::set_dummy25(::google::protobuf::int32 value) {
  set_has_dummy25();
  dummy25_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestRequired.dummy25)
}

// optional int32 dummy26 = 26;
inline bool TestRequired::has_dummy26() const {
  return (_has_bits_[0] & 0x02000000u) != 0;
}
inline void TestRequired::set_has_dummy26() {
  _has_bits_[0] |= 0x02000000u;
}
inline void TestRequired::clear_has_dummy26() {
  _has_bits_[0] &= ~0x02000000u;
}
inline void TestRequired::clear_dummy26() {
  dummy26_ = 0;
  clear_has_dummy26();
}
inline ::google::protobuf::int32 TestRequired::dummy26() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestRequired.dummy26)
  return dummy26_;
}
inline void TestRequired::set_dummy26(::google::protobuf::int32 value) {
  set_has_dummy26();
  dummy26_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestRequired.dummy26)
}

// optional int32 dummy27 = 27;
inline bool TestRequired::has_dummy27() const {
  return (_has_bits_[0] & 0x04000000u) != 0;
}
inline void TestRequired::set_has_dummy27() {
  _has_bits_[0] |= 0x04000000u;
}
inline void TestRequired::clear_has_dummy27() {
  _has_bits_[0] &= ~0x04000000u;
}
inline void TestRequired::clear_dummy27() {
  dummy27_ = 0;
  clear_has_dummy27();
}
inline ::google::protobuf::int32 TestRequired::dummy27() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestRequired.dummy27)
  return dummy27_;
}
inline void TestRequired::set_dummy27(::google::protobuf::int32 value) {
  set_has_dummy27();
  dummy27_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestRequired.dummy27)
}

// optional int32 dummy28 = 28;
inline bool TestRequired::has_dummy28() const {
  return (_has_bits_[0] & 0x08000000u) != 0;
}
inline void TestRequired::set_has_dummy28() {
  _has_bits_[0] |= 0x08000000u;
}
inline void TestRequired::clear_has_dummy28() {
  _has_bits_[0] &= ~0x08000000u;
}
inline void TestRequired::clear_dummy28() {
  dummy28_ = 0;
  clear_has_dummy28();
}
inline ::google::protobuf::int32 TestRequired::dummy28() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestRequired.dummy28)
  return dummy28_;
}
inline void TestRequired::set_dummy28(::google::protobuf::int32 value) {
  set_has_dummy28();
  dummy28_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestRequired.dummy28)
}

// optional int32 dummy29 = 29;
inline bool TestRequired::has_dummy29() const {
  return (_has_bits_[0] & 0x10000000u) != 0;
}
inline void TestRequired::set_has_dummy29() {
  _has_bits_[0] |= 0x10000000u;
}
inline void TestRequired::clear_has_dummy29() {
  _has_bits_[0] &= ~0x10000000u;
}
inline void TestRequired::clear_dummy29() {
  dummy29_ = 0;
  clear_has_dummy29();
}
inline ::google::protobuf::int32 TestRequired::dummy29() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestRequired.dummy29)
  return dummy29_;
}
inline void TestRequired::set_dummy29(::google::protobuf::int32 value) {
  set_has_dummy29();
  dummy29_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestRequired.dummy29)
}

// optional int32 dummy30 = 30;
inline bool TestRequired::has_dummy30() const {
  return (_has_bits_[0] & 0x20000000u) != 0;
}
inline void TestRequired::set_has_dummy30() {
  _has_bits_[0] |= 0x20000000u;
}
inline void TestRequired::clear_has_dummy30() {
  _has_bits_[0] &= ~0x20000000u;
}
inline void TestRequired::clear_dummy30() {
  dummy30_ = 0;
  clear_has_dummy30();
}
inline ::google::protobuf::int32 TestRequired::dummy30() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestRequired.dummy30)
  return dummy30_;
}
inline void TestRequired::set_dummy30(::google::protobuf::int32 value) {
  set_has_dummy30();
  dummy30_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestRequired.dummy30)
}

// optional int32 dummy31 = 31;
inline bool TestRequired::has_dummy31() const {
  return (_has_bits_[0] & 0x40000000u) != 0;
}
inline void TestRequired::set_has_dummy31() {
  _has_bits_[0] |= 0x40000000u;
}
inline void TestRequired::clear_has_dummy31() {
  _has_bits_[0] &= ~0x40000000u;
}
inline void TestRequired::clear_dummy31() {
  dummy31_ = 0;
  clear_has_dummy31();
}
inline ::google::protobuf::int32 TestRequired::dummy31() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestRequired.dummy31)
  return dummy31_;
}
inline void TestRequired::set_dummy31(::google::protobuf::int32 value) {
  set_has_dummy31();
  dummy31_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestRequired.dummy31)
}

// optional int32 dummy32 = 32;
inline bool TestRequired::has_dummy32() const {
  return (_has_bits_[0] & 0x80000000u) != 0;
}
inline void TestRequired::set_has_dummy32() {
  _has_bits_[0] |= 0x80000000u;
}
inline void TestRequired::clear_has_dummy32() {
  _has_bits_[0] &= ~0x80000000u;
}
inline void TestRequired::clear_dummy32() {
  dummy32_ = 0;
  clear_has_dummy32();
}
inline ::google::protobuf::int32 TestRequired::dummy32() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestRequired.dummy32)
  return dummy32_;
}
inline void TestRequired::set_dummy32(::google::protobuf::int32 value) {
  set_has_dummy32();
  dummy32_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestRequired.dummy32)
}

// required int32 c = 33;
inline bool TestRequired::has_c() const {
  return (_has_bits_[1] & 0x00000001u) != 0;
}
inline void TestRequired::set_has_c() {
  _has_bits_[1] |= 0x00000001u;
}
inline void TestRequired::clear_has_c() {
  _has_bits_[1] &= ~0x00000001u;
}
inline void TestRequired::clear_c() {
  c_ = 0;
  clear_has_c();
}
inline ::google::protobuf::int32 TestRequired::c() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestRequired.c)
  return c_;
}
inline void TestRequired::set_c(::google::protobuf::int32 value) {
  set_has_c();
  c_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestRequired.c)
}

// -------------------------------------------------------------------

// TestRequiredForeign

// optional .protobuf_unittest.TestRequired optional_message = 1;
inline bool TestRequiredForeign::has_optional_message() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TestRequiredForeign::set_has_optional_message() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TestRequiredForeign::clear_has_optional_message() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TestRequiredForeign::clear_optional_message() {
  if (optional_message_ != NULL) optional_message_->Clear();
  clear_has_optional_message();
}
inline const ::protobuf_unittest::TestRequired& TestRequiredForeign::_internal_optional_message() const {
  return *optional_message_;
}
inline const ::protobuf_unittest::TestRequired& TestRequiredForeign::optional_message() const {
  const ::protobuf_unittest::TestRequired* p = optional_message_;
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestRequiredForeign.optional_message)
  return p != NULL ? *p : *reinterpret_cast<const ::protobuf_unittest::TestRequired*>(
      &::protobuf_unittest::_TestRequired_default_instance_);
}
inline ::protobuf_unittest::TestRequired* TestRequiredForeign::release_optional_message() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestRequiredForeign.optional_message)
  clear_has_optional_message();
  ::protobuf_unittest::TestRequired* temp = optional_message_;
  if (GetArenaNoVirtual() != NULL) {
    temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
  }
  optional_message_ = NULL;
  return temp;
}
inline ::protobuf_unittest::TestRequired* TestRequiredForeign::unsafe_arena_release_optional_message() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestRequiredForeign.optional_message)
  clear_has_optional_message();
  ::protobuf_unittest::TestRequired* temp = optional_message_;
  optional_message_ = NULL;
  return temp;
}
inline ::protobuf_unittest::TestRequired* TestRequiredForeign::mutable_optional_message() {
  set_has_optional_message();
  if (optional_message_ == NULL) {
    auto* p = CreateMaybeMessage<::protobuf_unittest::TestRequired>(GetArenaNoVirtual());
    optional_message_ = p;
  }
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestRequiredForeign.optional_message)
  return optional_message_;
}
inline void TestRequiredForeign::set_allocated_optional_message(::protobuf_unittest::TestRequired* optional_message) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete optional_message_;
  }
  if (optional_message) {
    ::google::protobuf::Arena* submessage_arena =
      ::google::protobuf::Arena::GetArena(optional_message);
    if (message_arena != submessage_arena) {
      optional_message = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, optional_message, submessage_arena);
    }
    set_has_optional_message();
  } else {
    clear_has_optional_message();
  }
  optional_message_ = optional_message;
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestRequiredForeign.optional_message)
}

// repeated .protobuf_unittest.TestRequired repeated_message = 2;
inline int TestRequiredForeign::repeated_message_size() const {
  return repeated_message_.size();
}
inline void TestRequiredForeign::clear_repeated_message() {
  repeated_message_.Clear();
}
inline ::protobuf_unittest::TestRequired* TestRequiredForeign::mutable_repeated_message(int index) {
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestRequiredForeign.repeated_message)
  return repeated_message_.Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::TestRequired >*
TestRequiredForeign::mutable_repeated_message() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestRequiredForeign.repeated_message)
  return &repeated_message_;
}
inline const ::protobuf_unittest::TestRequired& TestRequiredForeign::repeated_message(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestRequiredForeign.repeated_message)
  return repeated_message_.Get(index);
}
inline ::protobuf_unittest::TestRequired* TestRequiredForeign::add_repeated_message() {
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestRequiredForeign.repeated_message)
  return repeated_message_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::TestRequired >&
TestRequiredForeign::repeated_message() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestRequiredForeign.repeated_message)
  return repeated_message_;
}

// optional int32 dummy = 3;
inline bool TestRequiredForeign::has_dummy() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void TestRequiredForeign::set_has_dummy() {
  _has_bits_[0] |= 0x00000002u;
}
inline void TestRequiredForeign::clear_has_dummy() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void TestRequiredForeign::clear_dummy() {
  dummy_ = 0;
  clear_has_dummy();
}
inline ::google::protobuf::int32 TestRequiredForeign::dummy() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestRequiredForeign.dummy)
  return dummy_;
}
inline void TestRequiredForeign::set_dummy(::google::protobuf::int32 value) {
  set_has_dummy();
  dummy_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestRequiredForeign.dummy)
}

// -------------------------------------------------------------------

// TestRequiredMessage

// optional .protobuf_unittest.TestRequired optional_message = 1;
inline bool TestRequiredMessage::has_optional_message() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TestRequiredMessage::set_has_optional_message() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TestRequiredMessage::clear_has_optional_message() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TestRequiredMessage::clear_optional_message() {
  if (optional_message_ != NULL) optional_message_->Clear();
  clear_has_optional_message();
}
inline const ::protobuf_unittest::TestRequired& TestRequiredMessage::_internal_optional_message() const {
  return *optional_message_;
}
inline const ::protobuf_unittest::TestRequired& TestRequiredMessage::optional_message() const {
  const ::protobuf_unittest::TestRequired* p = optional_message_;
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestRequiredMessage.optional_message)
  return p != NULL ? *p : *reinterpret_cast<const ::protobuf_unittest::TestRequired*>(
      &::protobuf_unittest::_TestRequired_default_instance_);
}
inline ::protobuf_unittest::TestRequired* TestRequiredMessage::release_optional_message() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestRequiredMessage.optional_message)
  clear_has_optional_message();
  ::protobuf_unittest::TestRequired* temp = optional_message_;
  if (GetArenaNoVirtual() != NULL) {
    temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
  }
  optional_message_ = NULL;
  return temp;
}
inline ::protobuf_unittest::TestRequired* TestRequiredMessage::unsafe_arena_release_optional_message() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestRequiredMessage.optional_message)
  clear_has_optional_message();
  ::protobuf_unittest::TestRequired* temp = optional_message_;
  optional_message_ = NULL;
  return temp;
}
inline ::protobuf_unittest::TestRequired* TestRequiredMessage::mutable_optional_message() {
  set_has_optional_message();
  if (optional_message_ == NULL) {
    auto* p = CreateMaybeMessage<::protobuf_unittest::TestRequired>(GetArenaNoVirtual());
    optional_message_ = p;
  }
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestRequiredMessage.optional_message)
  return optional_message_;
}
inline void TestRequiredMessage::set_allocated_optional_message(::protobuf_unittest::TestRequired* optional_message) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete optional_message_;
  }
  if (optional_message) {
    ::google::protobuf::Arena* submessage_arena =
      ::google::protobuf::Arena::GetArena(optional_message);
    if (message_arena != submessage_arena) {
      optional_message = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, optional_message, submessage_arena);
    }
    set_has_optional_message();
  } else {
    clear_has_optional_message();
  }
  optional_message_ = optional_message;
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestRequiredMessage.optional_message)
}

// repeated .protobuf_unittest.TestRequired repeated_message = 2;
inline int TestRequiredMessage::repeated_message_size() const {
  return repeated_message_.size();
}
inline void TestRequiredMessage::clear_repeated_message() {
  repeated_message_.Clear();
}
inline ::protobuf_unittest::TestRequired* TestRequiredMessage::mutable_repeated_message(int index) {
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestRequiredMessage.repeated_message)
  return repeated_message_.Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::TestRequired >*
TestRequiredMessage::mutable_repeated_message() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestRequiredMessage.repeated_message)
  return &repeated_message_;
}
inline const ::protobuf_unittest::TestRequired& TestRequiredMessage::repeated_message(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestRequiredMessage.repeated_message)
  return repeated_message_.Get(index);
}
inline ::protobuf_unittest::TestRequired* TestRequiredMessage::add_repeated_message() {
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestRequiredMessage.repeated_message)
  return repeated_message_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::TestRequired >&
TestRequiredMessage::repeated_message() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestRequiredMessage.repeated_message)
  return repeated_message_;
}

// required .protobuf_unittest.TestRequired required_message = 3;
inline bool TestRequiredMessage::has_required_message() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void TestRequiredMessage::set_has_required_message() {
  _has_bits_[0] |= 0x00000002u;
}
inline void TestRequiredMessage::clear_has_required_message() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void TestRequiredMessage::clear_required_message() {
  if (required_message_ != NULL) required_message_->Clear();
  clear_has_required_message();
}
inline const ::protobuf_unittest::TestRequired& TestRequiredMessage::_internal_required_message() const {
  return *required_message_;
}
inline const ::protobuf_unittest::TestRequired& TestRequiredMessage::required_message() const {
  const ::protobuf_unittest::TestRequired* p = required_message_;
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestRequiredMessage.required_message)
  return p != NULL ? *p : *reinterpret_cast<const ::protobuf_unittest::TestRequired*>(
      &::protobuf_unittest::_TestRequired_default_instance_);
}
inline ::protobuf_unittest::TestRequired* TestRequiredMessage::release_required_message() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestRequiredMessage.required_message)
  clear_has_required_message();
  ::protobuf_unittest::TestRequired* temp = required_message_;
  if (GetArenaNoVirtual() != NULL) {
    temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
  }
  required_message_ = NULL;
  return temp;
}
inline ::protobuf_unittest::TestRequired* TestRequiredMessage::unsafe_arena_release_required_message() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestRequiredMessage.required_message)
  clear_has_required_message();
  ::protobuf_unittest::TestRequired* temp = required_message_;
  required_message_ = NULL;
  return temp;
}
inline ::protobuf_unittest::TestRequired* TestRequiredMessage::mutable_required_message() {
  set_has_required_message();
  if (required_message_ == NULL) {
    auto* p = CreateMaybeMessage<::protobuf_unittest::TestRequired>(GetArenaNoVirtual());
    required_message_ = p;
  }
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestRequiredMessage.required_message)
  return required_message_;
}
inline void TestRequiredMessage::set_allocated_required_message(::protobuf_unittest::TestRequired* required_message) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete required_message_;
  }
  if (required_message) {
    ::google::protobuf::Arena* submessage_arena =
      ::google::protobuf::Arena::GetArena(required_message);
    if (message_arena != submessage_arena) {
      required_message = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, required_message, submessage_arena);
    }
    set_has_required_message();
  } else {
    clear_has_required_message();
  }
  required_message_ = required_message;
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestRequiredMessage.required_message)
}

// -------------------------------------------------------------------

// TestForeignNested

// optional .protobuf_unittest.TestAllTypes.NestedMessage foreign_nested = 1;
inline bool TestForeignNested::has_foreign_nested() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TestForeignNested::set_has_foreign_nested() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TestForeignNested::clear_has_foreign_nested() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TestForeignNested::clear_foreign_nested() {
  if (foreign_nested_ != NULL) foreign_nested_->Clear();
  clear_has_foreign_nested();
}
inline const ::protobuf_unittest::TestAllTypes_NestedMessage& TestForeignNested::_internal_foreign_nested() const {
  return *foreign_nested_;
}
inline const ::protobuf_unittest::TestAllTypes_NestedMessage& TestForeignNested::foreign_nested() const {
  const ::protobuf_unittest::TestAllTypes_NestedMessage* p = foreign_nested_;
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestForeignNested.foreign_nested)
  return p != NULL ? *p : *reinterpret_cast<const ::protobuf_unittest::TestAllTypes_NestedMessage*>(
      &::protobuf_unittest::_TestAllTypes_NestedMessage_default_instance_);
}
inline ::protobuf_unittest::TestAllTypes_NestedMessage* TestForeignNested::release_foreign_nested() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestForeignNested.foreign_nested)
  clear_has_foreign_nested();
  ::protobuf_unittest::TestAllTypes_NestedMessage* temp = foreign_nested_;
  if (GetArenaNoVirtual() != NULL) {
    temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
  }
  foreign_nested_ = NULL;
  return temp;
}
inline ::protobuf_unittest::TestAllTypes_NestedMessage* TestForeignNested::unsafe_arena_release_foreign_nested() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestForeignNested.foreign_nested)
  clear_has_foreign_nested();
  ::protobuf_unittest::TestAllTypes_NestedMessage* temp = foreign_nested_;
  foreign_nested_ = NULL;
  return temp;
}
inline ::protobuf_unittest::TestAllTypes_NestedMessage* TestForeignNested::mutable_foreign_nested() {
  set_has_foreign_nested();
  if (foreign_nested_ == NULL) {
    auto* p = CreateMaybeMessage<::protobuf_unittest::TestAllTypes_NestedMessage>(GetArenaNoVirtual());
    foreign_nested_ = p;
  }
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestForeignNested.foreign_nested)
  return foreign_nested_;
}
inline void TestForeignNested::set_allocated_foreign_nested(::protobuf_unittest::TestAllTypes_NestedMessage* foreign_nested) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete foreign_nested_;
  }
  if (foreign_nested) {
    ::google::protobuf::Arena* submessage_arena =
      ::google::protobuf::Arena::GetArena(foreign_nested);
    if (message_arena != submessage_arena) {
      foreign_nested = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, foreign_nested, submessage_arena);
    }
    set_has_foreign_nested();
  } else {
    clear_has_foreign_nested();
  }
  foreign_nested_ = foreign_nested;
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestForeignNested.foreign_nested)
}

// -------------------------------------------------------------------

// TestEmptyMessage

// -------------------------------------------------------------------

// TestEmptyMessageWithExtensions

// -------------------------------------------------------------------

// TestMultipleExtensionRanges

// -------------------------------------------------------------------

// TestReallyLargeTagNumber

// optional int32 a = 1;
inline bool TestReallyLargeTagNumber::has_a() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TestReallyLargeTagNumber::set_has_a() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TestReallyLargeTagNumber::clear_has_a() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TestReallyLargeTagNumber::clear_a() {
  a_ = 0;
  clear_has_a();
}
inline ::google::protobuf::int32 TestReallyLargeTagNumber::a() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestReallyLargeTagNumber.a)
  return a_;
}
inline void TestReallyLargeTagNumber::set_a(::google::protobuf::int32 value) {
  set_has_a();
  a_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestReallyLargeTagNumber.a)
}

// optional int32 bb = 268435455;
inline bool TestReallyLargeTagNumber::has_bb() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void TestReallyLargeTagNumber::set_has_bb() {
  _has_bits_[0] |= 0x00000002u;
}
inline void TestReallyLargeTagNumber::clear_has_bb() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void TestReallyLargeTagNumber::clear_bb() {
  bb_ = 0;
  clear_has_bb();
}
inline ::google::protobuf::int32 TestReallyLargeTagNumber::bb() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestReallyLargeTagNumber.bb)
  return bb_;
}
inline void TestReallyLargeTagNumber::set_bb(::google::protobuf::int32 value) {
  set_has_bb();
  bb_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestReallyLargeTagNumber.bb)
}

// -------------------------------------------------------------------

// TestRecursiveMessage

// optional .protobuf_unittest.TestRecursiveMessage a = 1;
inline bool TestRecursiveMessage::has_a() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TestRecursiveMessage::set_has_a() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TestRecursiveMessage::clear_has_a() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TestRecursiveMessage::clear_a() {
  if (a_ != NULL) a_->Clear();
  clear_has_a();
}
inline const ::protobuf_unittest::TestRecursiveMessage& TestRecursiveMessage::_internal_a() const {
  return *a_;
}
inline const ::protobuf_unittest::TestRecursiveMessage& TestRecursiveMessage::a() const {
  const ::protobuf_unittest::TestRecursiveMessage* p = a_;
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestRecursiveMessage.a)
  return p != NULL ? *p : *reinterpret_cast<const ::protobuf_unittest::TestRecursiveMessage*>(
      &::protobuf_unittest::_TestRecursiveMessage_default_instance_);
}
inline ::protobuf_unittest::TestRecursiveMessage* TestRecursiveMessage::release_a() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestRecursiveMessage.a)
  clear_has_a();
  ::protobuf_unittest::TestRecursiveMessage* temp = a_;
  if (GetArenaNoVirtual() != NULL) {
    temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
  }
  a_ = NULL;
  return temp;
}
inline ::protobuf_unittest::TestRecursiveMessage* TestRecursiveMessage::unsafe_arena_release_a() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestRecursiveMessage.a)
  clear_has_a();
  ::protobuf_unittest::TestRecursiveMessage* temp = a_;
  a_ = NULL;
  return temp;
}
inline ::protobuf_unittest::TestRecursiveMessage* TestRecursiveMessage::mutable_a() {
  set_has_a();
  if (a_ == NULL) {
    auto* p = CreateMaybeMessage<::protobuf_unittest::TestRecursiveMessage>(GetArenaNoVirtual());
    a_ = p;
  }
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestRecursiveMessage.a)
  return a_;
}
inline void TestRecursiveMessage::set_allocated_a(::protobuf_unittest::TestRecursiveMessage* a) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete a_;
  }
  if (a) {
    ::google::protobuf::Arena* submessage_arena =
      ::google::protobuf::Arena::GetArena(a);
    if (message_arena != submessage_arena) {
      a = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, a, submessage_arena);
    }
    set_has_a();
  } else {
    clear_has_a();
  }
  a_ = a;
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestRecursiveMessage.a)
}

// optional int32 i = 2;
inline bool TestRecursiveMessage::has_i() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void TestRecursiveMessage::set_has_i() {
  _has_bits_[0] |= 0x00000002u;
}
inline void TestRecursiveMessage::clear_has_i() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void TestRecursiveMessage::clear_i() {
  i_ = 0;
  clear_has_i();
}
inline ::google::protobuf::int32 TestRecursiveMessage::i() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestRecursiveMessage.i)
  return i_;
}
inline void TestRecursiveMessage::set_i(::google::protobuf::int32 value) {
  set_has_i();
  i_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestRecursiveMessage.i)
}

// -------------------------------------------------------------------

// TestMutualRecursionA_SubMessage

// optional .protobuf_unittest.TestMutualRecursionB b = 1;
inline bool TestMutualRecursionA_SubMessage::has_b() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TestMutualRecursionA_SubMessage::set_has_b() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TestMutualRecursionA_SubMessage::clear_has_b() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TestMutualRecursionA_SubMessage::clear_b() {
  if (b_ != NULL) b_->Clear();
  clear_has_b();
}
inline const ::protobuf_unittest::TestMutualRecursionB& TestMutualRecursionA_SubMessage::_internal_b() const {
  return *b_;
}
inline const ::protobuf_unittest::TestMutualRecursionB& TestMutualRecursionA_SubMessage::b() const {
  const ::protobuf_unittest::TestMutualRecursionB* p = b_;
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestMutualRecursionA.SubMessage.b)
  return p != NULL ? *p : *reinterpret_cast<const ::protobuf_unittest::TestMutualRecursionB*>(
      &::protobuf_unittest::_TestMutualRecursionB_default_instance_);
}
inline ::protobuf_unittest::TestMutualRecursionB* TestMutualRecursionA_SubMessage::release_b() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestMutualRecursionA.SubMessage.b)
  clear_has_b();
  ::protobuf_unittest::TestMutualRecursionB* temp = b_;
  if (GetArenaNoVirtual() != NULL) {
    temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
  }
  b_ = NULL;
  return temp;
}
inline ::protobuf_unittest::TestMutualRecursionB* TestMutualRecursionA_SubMessage::unsafe_arena_release_b() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestMutualRecursionA.SubMessage.b)
  clear_has_b();
  ::protobuf_unittest::TestMutualRecursionB* temp = b_;
  b_ = NULL;
  return temp;
}
inline ::protobuf_unittest::TestMutualRecursionB* TestMutualRecursionA_SubMessage::mutable_b() {
  set_has_b();
  if (b_ == NULL) {
    auto* p = CreateMaybeMessage<::protobuf_unittest::TestMutualRecursionB>(GetArenaNoVirtual());
    b_ = p;
  }
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestMutualRecursionA.SubMessage.b)
  return b_;
}
inline void TestMutualRecursionA_SubMessage::set_allocated_b(::protobuf_unittest::TestMutualRecursionB* b) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete b_;
  }
  if (b) {
    ::google::protobuf::Arena* submessage_arena =
      ::google::protobuf::Arena::GetArena(b);
    if (message_arena != submessage_arena) {
      b = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, b, submessage_arena);
    }
    set_has_b();
  } else {
    clear_has_b();
  }
  b_ = b;
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestMutualRecursionA.SubMessage.b)
}

// -------------------------------------------------------------------

// TestMutualRecursionA_SubGroup

// optional .protobuf_unittest.TestMutualRecursionA.SubMessage sub_message = 3;
inline bool TestMutualRecursionA_SubGroup::has_sub_message() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TestMutualRecursionA_SubGroup::set_has_sub_message() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TestMutualRecursionA_SubGroup::clear_has_sub_message() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TestMutualRecursionA_SubGroup::clear_sub_message() {
  if (sub_message_ != NULL) sub_message_->Clear();
  clear_has_sub_message();
}
inline const ::protobuf_unittest::TestMutualRecursionA_SubMessage& TestMutualRecursionA_SubGroup::_internal_sub_message() const {
  return *sub_message_;
}
inline const ::protobuf_unittest::TestMutualRecursionA_SubMessage& TestMutualRecursionA_SubGroup::sub_message() const {
  const ::protobuf_unittest::TestMutualRecursionA_SubMessage* p = sub_message_;
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestMutualRecursionA.SubGroup.sub_message)
  return p != NULL ? *p : *reinterpret_cast<const ::protobuf_unittest::TestMutualRecursionA_SubMessage*>(
      &::protobuf_unittest::_TestMutualRecursionA_SubMessage_default_instance_);
}
inline ::protobuf_unittest::TestMutualRecursionA_SubMessage* TestMutualRecursionA_SubGroup::release_sub_message() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestMutualRecursionA.SubGroup.sub_message)
  clear_has_sub_message();
  ::protobuf_unittest::TestMutualRecursionA_SubMessage* temp = sub_message_;
  if (GetArenaNoVirtual() != NULL) {
    temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
  }
  sub_message_ = NULL;
  return temp;
}
inline ::protobuf_unittest::TestMutualRecursionA_SubMessage* TestMutualRecursionA_SubGroup::unsafe_arena_release_sub_message() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestMutualRecursionA.SubGroup.sub_message)
  clear_has_sub_message();
  ::protobuf_unittest::TestMutualRecursionA_SubMessage* temp = sub_message_;
  sub_message_ = NULL;
  return temp;
}
inline ::protobuf_unittest::TestMutualRecursionA_SubMessage* TestMutualRecursionA_SubGroup::mutable_sub_message() {
  set_has_sub_message();
  if (sub_message_ == NULL) {
    auto* p = CreateMaybeMessage<::protobuf_unittest::TestMutualRecursionA_SubMessage>(GetArenaNoVirtual());
    sub_message_ = p;
  }
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestMutualRecursionA.SubGroup.sub_message)
  return sub_message_;
}
inline void TestMutualRecursionA_SubGroup::set_allocated_sub_message(::protobuf_unittest::TestMutualRecursionA_SubMessage* sub_message) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete sub_message_;
  }
  if (sub_message) {
    ::google::protobuf::Arena* submessage_arena =
      ::google::protobuf::Arena::GetArena(sub_message);
    if (message_arena != submessage_arena) {
      sub_message = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, sub_message, submessage_arena);
    }
    set_has_sub_message();
  } else {
    clear_has_sub_message();
  }
  sub_message_ = sub_message;
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestMutualRecursionA.SubGroup.sub_message)
}

// optional .protobuf_unittest.TestAllTypes not_in_this_scc = 4;
inline bool TestMutualRecursionA_SubGroup::has_not_in_this_scc() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void TestMutualRecursionA_SubGroup::set_has_not_in_this_scc() {
  _has_bits_[0] |= 0x00000002u;
}
inline void TestMutualRecursionA_SubGroup::clear_has_not_in_this_scc() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void TestMutualRecursionA_SubGroup::clear_not_in_this_scc() {
  if (not_in_this_scc_ != NULL) not_in_this_scc_->Clear();
  clear_has_not_in_this_scc();
}
inline const ::protobuf_unittest::TestAllTypes& TestMutualRecursionA_SubGroup::_internal_not_in_this_scc() const {
  return *not_in_this_scc_;
}
inline const ::protobuf_unittest::TestAllTypes& TestMutualRecursionA_SubGroup::not_in_this_scc() const {
  const ::protobuf_unittest::TestAllTypes* p = not_in_this_scc_;
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestMutualRecursionA.SubGroup.not_in_this_scc)
  return p != NULL ? *p : *reinterpret_cast<const ::protobuf_unittest::TestAllTypes*>(
      &::protobuf_unittest::_TestAllTypes_default_instance_);
}
inline ::protobuf_unittest::TestAllTypes* TestMutualRecursionA_SubGroup::release_not_in_this_scc() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestMutualRecursionA.SubGroup.not_in_this_scc)
  clear_has_not_in_this_scc();
  ::protobuf_unittest::TestAllTypes* temp = not_in_this_scc_;
  if (GetArenaNoVirtual() != NULL) {
    temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
  }
  not_in_this_scc_ = NULL;
  return temp;
}
inline ::protobuf_unittest::TestAllTypes* TestMutualRecursionA_SubGroup::unsafe_arena_release_not_in_this_scc() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestMutualRecursionA.SubGroup.not_in_this_scc)
  clear_has_not_in_this_scc();
  ::protobuf_unittest::TestAllTypes* temp = not_in_this_scc_;
  not_in_this_scc_ = NULL;
  return temp;
}
inline ::protobuf_unittest::TestAllTypes* TestMutualRecursionA_SubGroup::mutable_not_in_this_scc() {
  set_has_not_in_this_scc();
  if (not_in_this_scc_ == NULL) {
    auto* p = CreateMaybeMessage<::protobuf_unittest::TestAllTypes>(GetArenaNoVirtual());
    not_in_this_scc_ = p;
  }
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestMutualRecursionA.SubGroup.not_in_this_scc)
  return not_in_this_scc_;
}
inline void TestMutualRecursionA_SubGroup::set_allocated_not_in_this_scc(::protobuf_unittest::TestAllTypes* not_in_this_scc) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete not_in_this_scc_;
  }
  if (not_in_this_scc) {
    ::google::protobuf::Arena* submessage_arena =
      ::google::protobuf::Arena::GetArena(not_in_this_scc);
    if (message_arena != submessage_arena) {
      not_in_this_scc = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, not_in_this_scc, submessage_arena);
    }
    set_has_not_in_this_scc();
  } else {
    clear_has_not_in_this_scc();
  }
  not_in_this_scc_ = not_in_this_scc;
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestMutualRecursionA.SubGroup.not_in_this_scc)
}

// -------------------------------------------------------------------

// TestMutualRecursionA

// optional .protobuf_unittest.TestMutualRecursionB bb = 1;
inline bool TestMutualRecursionA::has_bb() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TestMutualRecursionA::set_has_bb() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TestMutualRecursionA::clear_has_bb() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TestMutualRecursionA::clear_bb() {
  if (bb_ != NULL) bb_->Clear();
  clear_has_bb();
}
inline const ::protobuf_unittest::TestMutualRecursionB& TestMutualRecursionA::_internal_bb() const {
  return *bb_;
}
inline const ::protobuf_unittest::TestMutualRecursionB& TestMutualRecursionA::bb() const {
  const ::protobuf_unittest::TestMutualRecursionB* p = bb_;
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestMutualRecursionA.bb)
  return p != NULL ? *p : *reinterpret_cast<const ::protobuf_unittest::TestMutualRecursionB*>(
      &::protobuf_unittest::_TestMutualRecursionB_default_instance_);
}
inline ::protobuf_unittest::TestMutualRecursionB* TestMutualRecursionA::release_bb() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestMutualRecursionA.bb)
  clear_has_bb();
  ::protobuf_unittest::TestMutualRecursionB* temp = bb_;
  if (GetArenaNoVirtual() != NULL) {
    temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
  }
  bb_ = NULL;
  return temp;
}
inline ::protobuf_unittest::TestMutualRecursionB* TestMutualRecursionA::unsafe_arena_release_bb() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestMutualRecursionA.bb)
  clear_has_bb();
  ::protobuf_unittest::TestMutualRecursionB* temp = bb_;
  bb_ = NULL;
  return temp;
}
inline ::protobuf_unittest::TestMutualRecursionB* TestMutualRecursionA::mutable_bb() {
  set_has_bb();
  if (bb_ == NULL) {
    auto* p = CreateMaybeMessage<::protobuf_unittest::TestMutualRecursionB>(GetArenaNoVirtual());
    bb_ = p;
  }
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestMutualRecursionA.bb)
  return bb_;
}
inline void TestMutualRecursionA::set_allocated_bb(::protobuf_unittest::TestMutualRecursionB* bb) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete bb_;
  }
  if (bb) {
    ::google::protobuf::Arena* submessage_arena =
      ::google::protobuf::Arena::GetArena(bb);
    if (message_arena != submessage_arena) {
      bb = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, bb, submessage_arena);
    }
    set_has_bb();
  } else {
    clear_has_bb();
  }
  bb_ = bb;
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestMutualRecursionA.bb)
}

// optional group SubGroup = 2 { ... };
inline bool TestMutualRecursionA::has_subgroup() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void TestMutualRecursionA::set_has_subgroup() {
  _has_bits_[0] |= 0x00000002u;
}
inline void TestMutualRecursionA::clear_has_subgroup() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void TestMutualRecursionA::clear_subgroup() {
  if (subgroup_ != NULL) subgroup_->Clear();
  clear_has_subgroup();
}
inline const ::protobuf_unittest::TestMutualRecursionA_SubGroup& TestMutualRecursionA::_internal_subgroup() const {
  return *subgroup_;
}
inline const ::protobuf_unittest::TestMutualRecursionA_SubGroup& TestMutualRecursionA::subgroup() const {
  const ::protobuf_unittest::TestMutualRecursionA_SubGroup* p = subgroup_;
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestMutualRecursionA.subgroup)
  return p != NULL ? *p : *reinterpret_cast<const ::protobuf_unittest::TestMutualRecursionA_SubGroup*>(
      &::protobuf_unittest::_TestMutualRecursionA_SubGroup_default_instance_);
}
inline ::protobuf_unittest::TestMutualRecursionA_SubGroup* TestMutualRecursionA::release_subgroup() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestMutualRecursionA.subgroup)
  clear_has_subgroup();
  ::protobuf_unittest::TestMutualRecursionA_SubGroup* temp = subgroup_;
  if (GetArenaNoVirtual() != NULL) {
    temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
  }
  subgroup_ = NULL;
  return temp;
}
inline ::protobuf_unittest::TestMutualRecursionA_SubGroup* TestMutualRecursionA::unsafe_arena_release_subgroup() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestMutualRecursionA.subgroup)
  clear_has_subgroup();
  ::protobuf_unittest::TestMutualRecursionA_SubGroup* temp = subgroup_;
  subgroup_ = NULL;
  return temp;
}
inline ::protobuf_unittest::TestMutualRecursionA_SubGroup* TestMutualRecursionA::mutable_subgroup() {
  set_has_subgroup();
  if (subgroup_ == NULL) {
    auto* p = CreateMaybeMessage<::protobuf_unittest::TestMutualRecursionA_SubGroup>(GetArenaNoVirtual());
    subgroup_ = p;
  }
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestMutualRecursionA.subgroup)
  return subgroup_;
}
inline void TestMutualRecursionA::set_allocated_subgroup(::protobuf_unittest::TestMutualRecursionA_SubGroup* subgroup) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete subgroup_;
  }
  if (subgroup) {
    ::google::protobuf::Arena* submessage_arena =
      ::google::protobuf::Arena::GetArena(subgroup);
    if (message_arena != submessage_arena) {
      subgroup = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, subgroup, submessage_arena);
    }
    set_has_subgroup();
  } else {
    clear_has_subgroup();
  }
  subgroup_ = subgroup;
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestMutualRecursionA.subgroup)
}

// -------------------------------------------------------------------

// TestMutualRecursionB

// optional .protobuf_unittest.TestMutualRecursionA a = 1;
inline bool TestMutualRecursionB::has_a() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TestMutualRecursionB::set_has_a() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TestMutualRecursionB::clear_has_a() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TestMutualRecursionB::clear_a() {
  if (a_ != NULL) a_->Clear();
  clear_has_a();
}
inline const ::protobuf_unittest::TestMutualRecursionA& TestMutualRecursionB::_internal_a() const {
  return *a_;
}
inline const ::protobuf_unittest::TestMutualRecursionA& TestMutualRecursionB::a() const {
  const ::protobuf_unittest::TestMutualRecursionA* p = a_;
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestMutualRecursionB.a)
  return p != NULL ? *p : *reinterpret_cast<const ::protobuf_unittest::TestMutualRecursionA*>(
      &::protobuf_unittest::_TestMutualRecursionA_default_instance_);
}
inline ::protobuf_unittest::TestMutualRecursionA* TestMutualRecursionB::release_a() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestMutualRecursionB.a)
  clear_has_a();
  ::protobuf_unittest::TestMutualRecursionA* temp = a_;
  if (GetArenaNoVirtual() != NULL) {
    temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
  }
  a_ = NULL;
  return temp;
}
inline ::protobuf_unittest::TestMutualRecursionA* TestMutualRecursionB::unsafe_arena_release_a() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestMutualRecursionB.a)
  clear_has_a();
  ::protobuf_unittest::TestMutualRecursionA* temp = a_;
  a_ = NULL;
  return temp;
}
inline ::protobuf_unittest::TestMutualRecursionA* TestMutualRecursionB::mutable_a() {
  set_has_a();
  if (a_ == NULL) {
    auto* p = CreateMaybeMessage<::protobuf_unittest::TestMutualRecursionA>(GetArenaNoVirtual());
    a_ = p;
  }
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestMutualRecursionB.a)
  return a_;
}
inline void TestMutualRecursionB::set_allocated_a(::protobuf_unittest::TestMutualRecursionA* a) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete a_;
  }
  if (a) {
    ::google::protobuf::Arena* submessage_arena =
      ::google::protobuf::Arena::GetArena(a);
    if (message_arena != submessage_arena) {
      a = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, a, submessage_arena);
    }
    set_has_a();
  } else {
    clear_has_a();
  }
  a_ = a;
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestMutualRecursionB.a)
}

// optional int32 optional_int32 = 2;
inline bool TestMutualRecursionB::has_optional_int32() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void TestMutualRecursionB::set_has_optional_int32() {
  _has_bits_[0] |= 0x00000002u;
}
inline void TestMutualRecursionB::clear_has_optional_int32() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void TestMutualRecursionB::clear_optional_int32() {
  optional_int32_ = 0;
  clear_has_optional_int32();
}
inline ::google::protobuf::int32 TestMutualRecursionB::optional_int32() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestMutualRecursionB.optional_int32)
  return optional_int32_;
}
inline void TestMutualRecursionB::set_optional_int32(::google::protobuf::int32 value) {
  set_has_optional_int32();
  optional_int32_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestMutualRecursionB.optional_int32)
}

// -------------------------------------------------------------------

// TestIsInitialized_SubMessage_SubGroup

// required int32 i = 2;
inline bool TestIsInitialized_SubMessage_SubGroup::has_i() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TestIsInitialized_SubMessage_SubGroup::set_has_i() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TestIsInitialized_SubMessage_SubGroup::clear_has_i() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TestIsInitialized_SubMessage_SubGroup::clear_i() {
  i_ = 0;
  clear_has_i();
}
inline ::google::protobuf::int32 TestIsInitialized_SubMessage_SubGroup::i() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestIsInitialized.SubMessage.SubGroup.i)
  return i_;
}
inline void TestIsInitialized_SubMessage_SubGroup::set_i(::google::protobuf::int32 value) {
  set_has_i();
  i_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestIsInitialized.SubMessage.SubGroup.i)
}

// -------------------------------------------------------------------

// TestIsInitialized_SubMessage

// optional group SubGroup = 1 { ... };
inline bool TestIsInitialized_SubMessage::has_subgroup() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TestIsInitialized_SubMessage::set_has_subgroup() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TestIsInitialized_SubMessage::clear_has_subgroup() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TestIsInitialized_SubMessage::clear_subgroup() {
  if (subgroup_ != NULL) subgroup_->Clear();
  clear_has_subgroup();
}
inline const ::protobuf_unittest::TestIsInitialized_SubMessage_SubGroup& TestIsInitialized_SubMessage::_internal_subgroup() const {
  return *subgroup_;
}
inline const ::protobuf_unittest::TestIsInitialized_SubMessage_SubGroup& TestIsInitialized_SubMessage::subgroup() const {
  const ::protobuf_unittest::TestIsInitialized_SubMessage_SubGroup* p = subgroup_;
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestIsInitialized.SubMessage.subgroup)
  return p != NULL ? *p : *reinterpret_cast<const ::protobuf_unittest::TestIsInitialized_SubMessage_SubGroup*>(
      &::protobuf_unittest::_TestIsInitialized_SubMessage_SubGroup_default_instance_);
}
inline ::protobuf_unittest::TestIsInitialized_SubMessage_SubGroup* TestIsInitialized_SubMessage::release_subgroup() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestIsInitialized.SubMessage.subgroup)
  clear_has_subgroup();
  ::protobuf_unittest::TestIsInitialized_SubMessage_SubGroup* temp = subgroup_;
  if (GetArenaNoVirtual() != NULL) {
    temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
  }
  subgroup_ = NULL;
  return temp;
}
inline ::protobuf_unittest::TestIsInitialized_SubMessage_SubGroup* TestIsInitialized_SubMessage::unsafe_arena_release_subgroup() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestIsInitialized.SubMessage.subgroup)
  clear_has_subgroup();
  ::protobuf_unittest::TestIsInitialized_SubMessage_SubGroup* temp = subgroup_;
  subgroup_ = NULL;
  return temp;
}
inline ::protobuf_unittest::TestIsInitialized_SubMessage_SubGroup* TestIsInitialized_SubMessage::mutable_subgroup() {
  set_has_subgroup();
  if (subgroup_ == NULL) {
    auto* p = CreateMaybeMessage<::protobuf_unittest::TestIsInitialized_SubMessage_SubGroup>(GetArenaNoVirtual());
    subgroup_ = p;
  }
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestIsInitialized.SubMessage.subgroup)
  return subgroup_;
}
inline void TestIsInitialized_SubMessage::set_allocated_subgroup(::protobuf_unittest::TestIsInitialized_SubMessage_SubGroup* subgroup) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete subgroup_;
  }
  if (subgroup) {
    ::google::protobuf::Arena* submessage_arena =
      ::google::protobuf::Arena::GetArena(subgroup);
    if (message_arena != submessage_arena) {
      subgroup = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, subgroup, submessage_arena);
    }
    set_has_subgroup();
  } else {
    clear_has_subgroup();
  }
  subgroup_ = subgroup;
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestIsInitialized.SubMessage.subgroup)
}

// -------------------------------------------------------------------

// TestIsInitialized

// optional .protobuf_unittest.TestIsInitialized.SubMessage sub_message = 1;
inline bool TestIsInitialized::has_sub_message() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TestIsInitialized::set_has_sub_message() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TestIsInitialized::clear_has_sub_message() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TestIsInitialized::clear_sub_message() {
  if (sub_message_ != NULL) sub_message_->Clear();
  clear_has_sub_message();
}
inline const ::protobuf_unittest::TestIsInitialized_SubMessage& TestIsInitialized::_internal_sub_message() const {
  return *sub_message_;
}
inline const ::protobuf_unittest::TestIsInitialized_SubMessage& TestIsInitialized::sub_message() const {
  const ::protobuf_unittest::TestIsInitialized_SubMessage* p = sub_message_;
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestIsInitialized.sub_message)
  return p != NULL ? *p : *reinterpret_cast<const ::protobuf_unittest::TestIsInitialized_SubMessage*>(
      &::protobuf_unittest::_TestIsInitialized_SubMessage_default_instance_);
}
inline ::protobuf_unittest::TestIsInitialized_SubMessage* TestIsInitialized::release_sub_message() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestIsInitialized.sub_message)
  clear_has_sub_message();
  ::protobuf_unittest::TestIsInitialized_SubMessage* temp = sub_message_;
  if (GetArenaNoVirtual() != NULL) {
    temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
  }
  sub_message_ = NULL;
  return temp;
}
inline ::protobuf_unittest::TestIsInitialized_SubMessage* TestIsInitialized::unsafe_arena_release_sub_message() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestIsInitialized.sub_message)
  clear_has_sub_message();
  ::protobuf_unittest::TestIsInitialized_SubMessage* temp = sub_message_;
  sub_message_ = NULL;
  return temp;
}
inline ::protobuf_unittest::TestIsInitialized_SubMessage* TestIsInitialized::mutable_sub_message() {
  set_has_sub_message();
  if (sub_message_ == NULL) {
    auto* p = CreateMaybeMessage<::protobuf_unittest::TestIsInitialized_SubMessage>(GetArenaNoVirtual());
    sub_message_ = p;
  }
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestIsInitialized.sub_message)
  return sub_message_;
}
inline void TestIsInitialized::set_allocated_sub_message(::protobuf_unittest::TestIsInitialized_SubMessage* sub_message) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete sub_message_;
  }
  if (sub_message) {
    ::google::protobuf::Arena* submessage_arena =
      ::google::protobuf::Arena::GetArena(sub_message);
    if (message_arena != submessage_arena) {
      sub_message = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, sub_message, submessage_arena);
    }
    set_has_sub_message();
  } else {
    clear_has_sub_message();
  }
  sub_message_ = sub_message;
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestIsInitialized.sub_message)
}

// -------------------------------------------------------------------

// TestDupFieldNumber_Foo

// optional int32 a = 1;
inline bool TestDupFieldNumber_Foo::has_a() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TestDupFieldNumber_Foo::set_has_a() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TestDupFieldNumber_Foo::clear_has_a() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TestDupFieldNumber_Foo::clear_a() {
  a_ = 0;
  clear_has_a();
}
inline ::google::protobuf::int32 TestDupFieldNumber_Foo::a() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestDupFieldNumber.Foo.a)
  return a_;
}
inline void TestDupFieldNumber_Foo::set_a(::google::protobuf::int32 value) {
  set_has_a();
  a_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestDupFieldNumber.Foo.a)
}

// -------------------------------------------------------------------

// TestDupFieldNumber_Bar

// optional int32 a = 1;
inline bool TestDupFieldNumber_Bar::has_a() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TestDupFieldNumber_Bar::set_has_a() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TestDupFieldNumber_Bar::clear_has_a() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TestDupFieldNumber_Bar::clear_a() {
  a_ = 0;
  clear_has_a();
}
inline ::google::protobuf::int32 TestDupFieldNumber_Bar::a() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestDupFieldNumber.Bar.a)
  return a_;
}
inline void TestDupFieldNumber_Bar::set_a(::google::protobuf::int32 value) {
  set_has_a();
  a_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestDupFieldNumber.Bar.a)
}

// -------------------------------------------------------------------

// TestDupFieldNumber

// optional int32 a = 1;
inline bool TestDupFieldNumber::has_a() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void TestDupFieldNumber::set_has_a() {
  _has_bits_[0] |= 0x00000004u;
}
inline void TestDupFieldNumber::clear_has_a() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void TestDupFieldNumber::clear_a() {
  a_ = 0;
  clear_has_a();
}
inline ::google::protobuf::int32 TestDupFieldNumber::a() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestDupFieldNumber.a)
  return a_;
}
inline void TestDupFieldNumber::set_a(::google::protobuf::int32 value) {
  set_has_a();
  a_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestDupFieldNumber.a)
}

// optional group Foo = 2 { ... };
inline bool TestDupFieldNumber::has_foo() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TestDupFieldNumber::set_has_foo() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TestDupFieldNumber::clear_has_foo() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TestDupFieldNumber::clear_foo() {
  if (foo_ != NULL) foo_->Clear();
  clear_has_foo();
}
inline const ::protobuf_unittest::TestDupFieldNumber_Foo& TestDupFieldNumber::_internal_foo() const {
  return *foo_;
}
inline const ::protobuf_unittest::TestDupFieldNumber_Foo& TestDupFieldNumber::foo() const {
  const ::protobuf_unittest::TestDupFieldNumber_Foo* p = foo_;
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestDupFieldNumber.foo)
  return p != NULL ? *p : *reinterpret_cast<const ::protobuf_unittest::TestDupFieldNumber_Foo*>(
      &::protobuf_unittest::_TestDupFieldNumber_Foo_default_instance_);
}
inline ::protobuf_unittest::TestDupFieldNumber_Foo* TestDupFieldNumber::release_foo() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestDupFieldNumber.foo)
  clear_has_foo();
  ::protobuf_unittest::TestDupFieldNumber_Foo* temp = foo_;
  if (GetArenaNoVirtual() != NULL) {
    temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
  }
  foo_ = NULL;
  return temp;
}
inline ::protobuf_unittest::TestDupFieldNumber_Foo* TestDupFieldNumber::unsafe_arena_release_foo() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestDupFieldNumber.foo)
  clear_has_foo();
  ::protobuf_unittest::TestDupFieldNumber_Foo* temp = foo_;
  foo_ = NULL;
  return temp;
}
inline ::protobuf_unittest::TestDupFieldNumber_Foo* TestDupFieldNumber::mutable_foo() {
  set_has_foo();
  if (foo_ == NULL) {
    auto* p = CreateMaybeMessage<::protobuf_unittest::TestDupFieldNumber_Foo>(GetArenaNoVirtual());
    foo_ = p;
  }
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestDupFieldNumber.foo)
  return foo_;
}
inline void TestDupFieldNumber::set_allocated_foo(::protobuf_unittest::TestDupFieldNumber_Foo* foo) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete foo_;
  }
  if (foo) {
    ::google::protobuf::Arena* submessage_arena =
      ::google::protobuf::Arena::GetArena(foo);
    if (message_arena != submessage_arena) {
      foo = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, foo, submessage_arena);
    }
    set_has_foo();
  } else {
    clear_has_foo();
  }
  foo_ = foo;
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestDupFieldNumber.foo)
}

// optional group Bar = 3 { ... };
inline bool TestDupFieldNumber::has_bar() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void TestDupFieldNumber::set_has_bar() {
  _has_bits_[0] |= 0x00000002u;
}
inline void TestDupFieldNumber::clear_has_bar() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void TestDupFieldNumber::clear_bar() {
  if (bar_ != NULL) bar_->Clear();
  clear_has_bar();
}
inline const ::protobuf_unittest::TestDupFieldNumber_Bar& TestDupFieldNumber::_internal_bar() const {
  return *bar_;
}
inline const ::protobuf_unittest::TestDupFieldNumber_Bar& TestDupFieldNumber::bar() const {
  const ::protobuf_unittest::TestDupFieldNumber_Bar* p = bar_;
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestDupFieldNumber.bar)
  return p != NULL ? *p : *reinterpret_cast<const ::protobuf_unittest::TestDupFieldNumber_Bar*>(
      &::protobuf_unittest::_TestDupFieldNumber_Bar_default_instance_);
}
inline ::protobuf_unittest::TestDupFieldNumber_Bar* TestDupFieldNumber::release_bar() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestDupFieldNumber.bar)
  clear_has_bar();
  ::protobuf_unittest::TestDupFieldNumber_Bar* temp = bar_;
  if (GetArenaNoVirtual() != NULL) {
    temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
  }
  bar_ = NULL;
  return temp;
}
inline ::protobuf_unittest::TestDupFieldNumber_Bar* TestDupFieldNumber::unsafe_arena_release_bar() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestDupFieldNumber.bar)
  clear_has_bar();
  ::protobuf_unittest::TestDupFieldNumber_Bar* temp = bar_;
  bar_ = NULL;
  return temp;
}
inline ::protobuf_unittest::TestDupFieldNumber_Bar* TestDupFieldNumber::mutable_bar() {
  set_has_bar();
  if (bar_ == NULL) {
    auto* p = CreateMaybeMessage<::protobuf_unittest::TestDupFieldNumber_Bar>(GetArenaNoVirtual());
    bar_ = p;
  }
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestDupFieldNumber.bar)
  return bar_;
}
inline void TestDupFieldNumber::set_allocated_bar(::protobuf_unittest::TestDupFieldNumber_Bar* bar) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete bar_;
  }
  if (bar) {
    ::google::protobuf::Arena* submessage_arena =
      ::google::protobuf::Arena::GetArena(bar);
    if (message_arena != submessage_arena) {
      bar = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, bar, submessage_arena);
    }
    set_has_bar();
  } else {
    clear_has_bar();
  }
  bar_ = bar;
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestDupFieldNumber.bar)
}

// -------------------------------------------------------------------

// TestEagerMessage

// optional .protobuf_unittest.TestAllTypes sub_message = 1 [lazy = false];
inline bool TestEagerMessage::has_sub_message() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TestEagerMessage::set_has_sub_message() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TestEagerMessage::clear_has_sub_message() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TestEagerMessage::clear_sub_message() {
  if (sub_message_ != NULL) sub_message_->Clear();
  clear_has_sub_message();
}
inline const ::protobuf_unittest::TestAllTypes& TestEagerMessage::_internal_sub_message() const {
  return *sub_message_;
}
inline const ::protobuf_unittest::TestAllTypes& TestEagerMessage::sub_message() const {
  const ::protobuf_unittest::TestAllTypes* p = sub_message_;
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestEagerMessage.sub_message)
  return p != NULL ? *p : *reinterpret_cast<const ::protobuf_unittest::TestAllTypes*>(
      &::protobuf_unittest::_TestAllTypes_default_instance_);
}
inline ::protobuf_unittest::TestAllTypes* TestEagerMessage::release_sub_message() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestEagerMessage.sub_message)
  clear_has_sub_message();
  ::protobuf_unittest::TestAllTypes* temp = sub_message_;
  if (GetArenaNoVirtual() != NULL) {
    temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
  }
  sub_message_ = NULL;
  return temp;
}
inline ::protobuf_unittest::TestAllTypes* TestEagerMessage::unsafe_arena_release_sub_message() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestEagerMessage.sub_message)
  clear_has_sub_message();
  ::protobuf_unittest::TestAllTypes* temp = sub_message_;
  sub_message_ = NULL;
  return temp;
}
inline ::protobuf_unittest::TestAllTypes* TestEagerMessage::mutable_sub_message() {
  set_has_sub_message();
  if (sub_message_ == NULL) {
    auto* p = CreateMaybeMessage<::protobuf_unittest::TestAllTypes>(GetArenaNoVirtual());
    sub_message_ = p;
  }
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestEagerMessage.sub_message)
  return sub_message_;
}
inline void TestEagerMessage::set_allocated_sub_message(::protobuf_unittest::TestAllTypes* sub_message) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete sub_message_;
  }
  if (sub_message) {
    ::google::protobuf::Arena* submessage_arena =
      ::google::protobuf::Arena::GetArena(sub_message);
    if (message_arena != submessage_arena) {
      sub_message = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, sub_message, submessage_arena);
    }
    set_has_sub_message();
  } else {
    clear_has_sub_message();
  }
  sub_message_ = sub_message;
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestEagerMessage.sub_message)
}

// -------------------------------------------------------------------

// TestLazyMessage

// optional .protobuf_unittest.TestAllTypes sub_message = 1 [lazy = true];
inline bool TestLazyMessage::has_sub_message() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TestLazyMessage::set_has_sub_message() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TestLazyMessage::clear_has_sub_message() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TestLazyMessage::clear_sub_message() {
  if (sub_message_ != NULL) sub_message_->Clear();
  clear_has_sub_message();
}
inline const ::protobuf_unittest::TestAllTypes& TestLazyMessage::_internal_sub_message() const {
  return *sub_message_;
}
inline const ::protobuf_unittest::TestAllTypes& TestLazyMessage::sub_message() const {
  const ::protobuf_unittest::TestAllTypes* p = sub_message_;
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestLazyMessage.sub_message)
  return p != NULL ? *p : *reinterpret_cast<const ::protobuf_unittest::TestAllTypes*>(
      &::protobuf_unittest::_TestAllTypes_default_instance_);
}
inline ::protobuf_unittest::TestAllTypes* TestLazyMessage::release_sub_message() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestLazyMessage.sub_message)
  clear_has_sub_message();
  ::protobuf_unittest::TestAllTypes* temp = sub_message_;
  if (GetArenaNoVirtual() != NULL) {
    temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
  }
  sub_message_ = NULL;
  return temp;
}
inline ::protobuf_unittest::TestAllTypes* TestLazyMessage::unsafe_arena_release_sub_message() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestLazyMessage.sub_message)
  clear_has_sub_message();
  ::protobuf_unittest::TestAllTypes* temp = sub_message_;
  sub_message_ = NULL;
  return temp;
}
inline ::protobuf_unittest::TestAllTypes* TestLazyMessage::mutable_sub_message() {
  set_has_sub_message();
  if (sub_message_ == NULL) {
    auto* p = CreateMaybeMessage<::protobuf_unittest::TestAllTypes>(GetArenaNoVirtual());
    sub_message_ = p;
  }
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestLazyMessage.sub_message)
  return sub_message_;
}
inline void TestLazyMessage::set_allocated_sub_message(::protobuf_unittest::TestAllTypes* sub_message) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete sub_message_;
  }
  if (sub_message) {
    ::google::protobuf::Arena* submessage_arena =
      ::google::protobuf::Arena::GetArena(sub_message);
    if (message_arena != submessage_arena) {
      sub_message = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, sub_message, submessage_arena);
    }
    set_has_sub_message();
  } else {
    clear_has_sub_message();
  }
  sub_message_ = sub_message;
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestLazyMessage.sub_message)
}

// -------------------------------------------------------------------

// TestNestedMessageHasBits_NestedMessage

// repeated int32 nestedmessage_repeated_int32 = 1;
inline int TestNestedMessageHasBits_NestedMessage::nestedmessage_repeated_int32_size() const {
  return nestedmessage_repeated_int32_.size();
}
inline void TestNestedMessageHasBits_NestedMessage::clear_nestedmessage_repeated_int32() {
  nestedmessage_repeated_int32_.Clear();
}
inline ::google::protobuf::int32 TestNestedMessageHasBits_NestedMessage::nestedmessage_repeated_int32(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestNestedMessageHasBits.NestedMessage.nestedmessage_repeated_int32)
  return nestedmessage_repeated_int32_.Get(index);
}
inline void TestNestedMessageHasBits_NestedMessage::set_nestedmessage_repeated_int32(int index, ::google::protobuf::int32 value) {
  nestedmessage_repeated_int32_.Set(index, value);
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestNestedMessageHasBits.NestedMessage.nestedmessage_repeated_int32)
}
inline void TestNestedMessageHasBits_NestedMessage::add_nestedmessage_repeated_int32(::google::protobuf::int32 value) {
  nestedmessage_repeated_int32_.Add(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestNestedMessageHasBits.NestedMessage.nestedmessage_repeated_int32)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
TestNestedMessageHasBits_NestedMessage::nestedmessage_repeated_int32() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestNestedMessageHasBits.NestedMessage.nestedmessage_repeated_int32)
  return nestedmessage_repeated_int32_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
TestNestedMessageHasBits_NestedMessage::mutable_nestedmessage_repeated_int32() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestNestedMessageHasBits.NestedMessage.nestedmessage_repeated_int32)
  return &nestedmessage_repeated_int32_;
}

// repeated .protobuf_unittest.ForeignMessage nestedmessage_repeated_foreignmessage = 2;
inline int TestNestedMessageHasBits_NestedMessage::nestedmessage_repeated_foreignmessage_size() const {
  return nestedmessage_repeated_foreignmessage_.size();
}
inline void TestNestedMessageHasBits_NestedMessage::clear_nestedmessage_repeated_foreignmessage() {
  nestedmessage_repeated_foreignmessage_.Clear();
}
inline ::protobuf_unittest::ForeignMessage* TestNestedMessageHasBits_NestedMessage::mutable_nestedmessage_repeated_foreignmessage(int index) {
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestNestedMessageHasBits.NestedMessage.nestedmessage_repeated_foreignmessage)
  return nestedmessage_repeated_foreignmessage_.Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::ForeignMessage >*
TestNestedMessageHasBits_NestedMessage::mutable_nestedmessage_repeated_foreignmessage() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestNestedMessageHasBits.NestedMessage.nestedmessage_repeated_foreignmessage)
  return &nestedmessage_repeated_foreignmessage_;
}
inline const ::protobuf_unittest::ForeignMessage& TestNestedMessageHasBits_NestedMessage::nestedmessage_repeated_foreignmessage(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestNestedMessageHasBits.NestedMessage.nestedmessage_repeated_foreignmessage)
  return nestedmessage_repeated_foreignmessage_.Get(index);
}
inline ::protobuf_unittest::ForeignMessage* TestNestedMessageHasBits_NestedMessage::add_nestedmessage_repeated_foreignmessage() {
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestNestedMessageHasBits.NestedMessage.nestedmessage_repeated_foreignmessage)
  return nestedmessage_repeated_foreignmessage_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::ForeignMessage >&
TestNestedMessageHasBits_NestedMessage::nestedmessage_repeated_foreignmessage() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestNestedMessageHasBits.NestedMessage.nestedmessage_repeated_foreignmessage)
  return nestedmessage_repeated_foreignmessage_;
}

// -------------------------------------------------------------------

// TestNestedMessageHasBits

// optional .protobuf_unittest.TestNestedMessageHasBits.NestedMessage optional_nested_message = 1;
inline bool TestNestedMessageHasBits::has_optional_nested_message() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TestNestedMessageHasBits::set_has_optional_nested_message() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TestNestedMessageHasBits::clear_has_optional_nested_message() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TestNestedMessageHasBits::clear_optional_nested_message() {
  if (optional_nested_message_ != NULL) optional_nested_message_->Clear();
  clear_has_optional_nested_message();
}
inline const ::protobuf_unittest::TestNestedMessageHasBits_NestedMessage& TestNestedMessageHasBits::_internal_optional_nested_message() const {
  return *optional_nested_message_;
}
inline const ::protobuf_unittest::TestNestedMessageHasBits_NestedMessage& TestNestedMessageHasBits::optional_nested_message() const {
  const ::protobuf_unittest::TestNestedMessageHasBits_NestedMessage* p = optional_nested_message_;
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestNestedMessageHasBits.optional_nested_message)
  return p != NULL ? *p : *reinterpret_cast<const ::protobuf_unittest::TestNestedMessageHasBits_NestedMessage*>(
      &::protobuf_unittest::_TestNestedMessageHasBits_NestedMessage_default_instance_);
}
inline ::protobuf_unittest::TestNestedMessageHasBits_NestedMessage* TestNestedMessageHasBits::release_optional_nested_message() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestNestedMessageHasBits.optional_nested_message)
  clear_has_optional_nested_message();
  ::protobuf_unittest::TestNestedMessageHasBits_NestedMessage* temp = optional_nested_message_;
  if (GetArenaNoVirtual() != NULL) {
    temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
  }
  optional_nested_message_ = NULL;
  return temp;
}
inline ::protobuf_unittest::TestNestedMessageHasBits_NestedMessage* TestNestedMessageHasBits::unsafe_arena_release_optional_nested_message() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestNestedMessageHasBits.optional_nested_message)
  clear_has_optional_nested_message();
  ::protobuf_unittest::TestNestedMessageHasBits_NestedMessage* temp = optional_nested_message_;
  optional_nested_message_ = NULL;
  return temp;
}
inline ::protobuf_unittest::TestNestedMessageHasBits_NestedMessage* TestNestedMessageHasBits::mutable_optional_nested_message() {
  set_has_optional_nested_message();
  if (optional_nested_message_ == NULL) {
    auto* p = CreateMaybeMessage<::protobuf_unittest::TestNestedMessageHasBits_NestedMessage>(GetArenaNoVirtual());
    optional_nested_message_ = p;
  }
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestNestedMessageHasBits.optional_nested_message)
  return optional_nested_message_;
}
inline void TestNestedMessageHasBits::set_allocated_optional_nested_message(::protobuf_unittest::TestNestedMessageHasBits_NestedMessage* optional_nested_message) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete optional_nested_message_;
  }
  if (optional_nested_message) {
    ::google::protobuf::Arena* submessage_arena =
      ::google::protobuf::Arena::GetArena(optional_nested_message);
    if (message_arena != submessage_arena) {
      optional_nested_message = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, optional_nested_message, submessage_arena);
    }
    set_has_optional_nested_message();
  } else {
    clear_has_optional_nested_message();
  }
  optional_nested_message_ = optional_nested_message;
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestNestedMessageHasBits.optional_nested_message)
}

// -------------------------------------------------------------------

// TestCamelCaseFieldNames

// optional int32 PrimitiveField = 1;
inline bool TestCamelCaseFieldNames::has_primitivefield() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void TestCamelCaseFieldNames::set_has_primitivefield() {
  _has_bits_[0] |= 0x00000010u;
}
inline void TestCamelCaseFieldNames::clear_has_primitivefield() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void TestCamelCaseFieldNames::clear_primitivefield() {
  primitivefield_ = 0;
  clear_has_primitivefield();
}
inline ::google::protobuf::int32 TestCamelCaseFieldNames::primitivefield() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestCamelCaseFieldNames.PrimitiveField)
  return primitivefield_;
}
inline void TestCamelCaseFieldNames::set_primitivefield(::google::protobuf::int32 value) {
  set_has_primitivefield();
  primitivefield_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestCamelCaseFieldNames.PrimitiveField)
}

// optional string StringField = 2;
inline bool TestCamelCaseFieldNames::has_stringfield() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TestCamelCaseFieldNames::set_has_stringfield() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TestCamelCaseFieldNames::clear_has_stringfield() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TestCamelCaseFieldNames::clear_stringfield() {
  stringfield_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
  clear_has_stringfield();
}
inline const ::std::string& TestCamelCaseFieldNames::stringfield() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestCamelCaseFieldNames.StringField)
  return stringfield_.Get();
}
inline void TestCamelCaseFieldNames::set_stringfield(const ::std::string& value) {
  set_has_stringfield();
  stringfield_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestCamelCaseFieldNames.StringField)
}
#if LANG_CXX11
inline void TestCamelCaseFieldNames::set_stringfield(::std::string&& value) {
  set_has_stringfield();
  stringfield_.Set(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_rvalue:protobuf_unittest.TestCamelCaseFieldNames.StringField)
}
#endif
inline void TestCamelCaseFieldNames::set_stringfield(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_stringfield();
  stringfield_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_char:protobuf_unittest.TestCamelCaseFieldNames.StringField)
}
inline void TestCamelCaseFieldNames::set_stringfield(const char* value,
    size_t size) {
  set_has_stringfield();
  stringfield_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_pointer:protobuf_unittest.TestCamelCaseFieldNames.StringField)
}
inline ::std::string* TestCamelCaseFieldNames::mutable_stringfield() {
  set_has_stringfield();
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestCamelCaseFieldNames.StringField)
  return stringfield_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline ::std::string* TestCamelCaseFieldNames::release_stringfield() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestCamelCaseFieldNames.StringField)
  if (!has_stringfield()) {
    return NULL;
  }
  clear_has_stringfield();
  return stringfield_.ReleaseNonDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline void TestCamelCaseFieldNames::set_allocated_stringfield(::std::string* stringfield) {
  if (stringfield != NULL) {
    set_has_stringfield();
  } else {
    clear_has_stringfield();
  }
  stringfield_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), stringfield,
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestCamelCaseFieldNames.StringField)
}
inline ::std::string* TestCamelCaseFieldNames::unsafe_arena_release_stringfield() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestCamelCaseFieldNames.StringField)
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  clear_has_stringfield();
  return stringfield_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      GetArenaNoVirtual());
}
inline void TestCamelCaseFieldNames::unsafe_arena_set_allocated_stringfield(
    ::std::string* stringfield) {
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (stringfield != NULL) {
    set_has_stringfield();
  } else {
    clear_has_stringfield();
  }
  stringfield_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      stringfield, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf_unittest.TestCamelCaseFieldNames.StringField)
}

// optional .protobuf_unittest.ForeignEnum EnumField = 3;
inline bool TestCamelCaseFieldNames::has_enumfield() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void TestCamelCaseFieldNames::set_has_enumfield() {
  _has_bits_[0] |= 0x00000020u;
}
inline void TestCamelCaseFieldNames::clear_has_enumfield() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void TestCamelCaseFieldNames::clear_enumfield() {
  enumfield_ = 4;
  clear_has_enumfield();
}
inline ::protobuf_unittest::ForeignEnum TestCamelCaseFieldNames::enumfield() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestCamelCaseFieldNames.EnumField)
  return static_cast< ::protobuf_unittest::ForeignEnum >(enumfield_);
}
inline void TestCamelCaseFieldNames::set_enumfield(::protobuf_unittest::ForeignEnum value) {
  assert(::protobuf_unittest::ForeignEnum_IsValid(value));
  set_has_enumfield();
  enumfield_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestCamelCaseFieldNames.EnumField)
}

// optional .protobuf_unittest.ForeignMessage MessageField = 4;
inline bool TestCamelCaseFieldNames::has_messagefield() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void TestCamelCaseFieldNames::set_has_messagefield() {
  _has_bits_[0] |= 0x00000008u;
}
inline void TestCamelCaseFieldNames::clear_has_messagefield() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void TestCamelCaseFieldNames::clear_messagefield() {
  if (messagefield_ != NULL) messagefield_->Clear();
  clear_has_messagefield();
}
inline const ::protobuf_unittest::ForeignMessage& TestCamelCaseFieldNames::_internal_messagefield() const {
  return *messagefield_;
}
inline const ::protobuf_unittest::ForeignMessage& TestCamelCaseFieldNames::messagefield() const {
  const ::protobuf_unittest::ForeignMessage* p = messagefield_;
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestCamelCaseFieldNames.MessageField)
  return p != NULL ? *p : *reinterpret_cast<const ::protobuf_unittest::ForeignMessage*>(
      &::protobuf_unittest::_ForeignMessage_default_instance_);
}
inline ::protobuf_unittest::ForeignMessage* TestCamelCaseFieldNames::release_messagefield() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestCamelCaseFieldNames.MessageField)
  clear_has_messagefield();
  ::protobuf_unittest::ForeignMessage* temp = messagefield_;
  if (GetArenaNoVirtual() != NULL) {
    temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
  }
  messagefield_ = NULL;
  return temp;
}
inline ::protobuf_unittest::ForeignMessage* TestCamelCaseFieldNames::unsafe_arena_release_messagefield() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestCamelCaseFieldNames.MessageField)
  clear_has_messagefield();
  ::protobuf_unittest::ForeignMessage* temp = messagefield_;
  messagefield_ = NULL;
  return temp;
}
inline ::protobuf_unittest::ForeignMessage* TestCamelCaseFieldNames::mutable_messagefield() {
  set_has_messagefield();
  if (messagefield_ == NULL) {
    auto* p = CreateMaybeMessage<::protobuf_unittest::ForeignMessage>(GetArenaNoVirtual());
    messagefield_ = p;
  }
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestCamelCaseFieldNames.MessageField)
  return messagefield_;
}
inline void TestCamelCaseFieldNames::set_allocated_messagefield(::protobuf_unittest::ForeignMessage* messagefield) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete messagefield_;
  }
  if (messagefield) {
    ::google::protobuf::Arena* submessage_arena =
      ::google::protobuf::Arena::GetArena(messagefield);
    if (message_arena != submessage_arena) {
      messagefield = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, messagefield, submessage_arena);
    }
    set_has_messagefield();
  } else {
    clear_has_messagefield();
  }
  messagefield_ = messagefield;
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestCamelCaseFieldNames.MessageField)
}

// optional string StringPieceField = 5 [ctype = STRING_PIECE];
inline bool TestCamelCaseFieldNames::has_stringpiecefield() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void TestCamelCaseFieldNames::set_has_stringpiecefield() {
  _has_bits_[0] |= 0x00000002u;
}
inline void TestCamelCaseFieldNames::clear_has_stringpiecefield() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void TestCamelCaseFieldNames::clear_stringpiecefield() {
  stringpiecefield_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
  clear_has_stringpiecefield();
}
inline const ::std::string& TestCamelCaseFieldNames::stringpiecefield() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestCamelCaseFieldNames.StringPieceField)
  return stringpiecefield_.Get();
}
inline void TestCamelCaseFieldNames::set_stringpiecefield(const ::std::string& value) {
  set_has_stringpiecefield();
  stringpiecefield_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestCamelCaseFieldNames.StringPieceField)
}
#if LANG_CXX11
inline void TestCamelCaseFieldNames::set_stringpiecefield(::std::string&& value) {
  set_has_stringpiecefield();
  stringpiecefield_.Set(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_rvalue:protobuf_unittest.TestCamelCaseFieldNames.StringPieceField)
}
#endif
inline void TestCamelCaseFieldNames::set_stringpiecefield(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_stringpiecefield();
  stringpiecefield_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_char:protobuf_unittest.TestCamelCaseFieldNames.StringPieceField)
}
inline void TestCamelCaseFieldNames::set_stringpiecefield(const char* value,
    size_t size) {
  set_has_stringpiecefield();
  stringpiecefield_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_pointer:protobuf_unittest.TestCamelCaseFieldNames.StringPieceField)
}
inline ::std::string* TestCamelCaseFieldNames::mutable_stringpiecefield() {
  set_has_stringpiecefield();
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestCamelCaseFieldNames.StringPieceField)
  return stringpiecefield_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline ::std::string* TestCamelCaseFieldNames::release_stringpiecefield() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestCamelCaseFieldNames.StringPieceField)
  if (!has_stringpiecefield()) {
    return NULL;
  }
  clear_has_stringpiecefield();
  return stringpiecefield_.ReleaseNonDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline void TestCamelCaseFieldNames::set_allocated_stringpiecefield(::std::string* stringpiecefield) {
  if (stringpiecefield != NULL) {
    set_has_stringpiecefield();
  } else {
    clear_has_stringpiecefield();
  }
  stringpiecefield_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), stringpiecefield,
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestCamelCaseFieldNames.StringPieceField)
}
inline ::std::string* TestCamelCaseFieldNames::unsafe_arena_release_stringpiecefield() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestCamelCaseFieldNames.StringPieceField)
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  clear_has_stringpiecefield();
  return stringpiecefield_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      GetArenaNoVirtual());
}
inline void TestCamelCaseFieldNames::unsafe_arena_set_allocated_stringpiecefield(
    ::std::string* stringpiecefield) {
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (stringpiecefield != NULL) {
    set_has_stringpiecefield();
  } else {
    clear_has_stringpiecefield();
  }
  stringpiecefield_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      stringpiecefield, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf_unittest.TestCamelCaseFieldNames.StringPieceField)
}

// optional string CordField = 6 [ctype = CORD];
inline bool TestCamelCaseFieldNames::has_cordfield() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void TestCamelCaseFieldNames::set_has_cordfield() {
  _has_bits_[0] |= 0x00000004u;
}
inline void TestCamelCaseFieldNames::clear_has_cordfield() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void TestCamelCaseFieldNames::clear_cordfield() {
  cordfield_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
  clear_has_cordfield();
}
inline const ::std::string& TestCamelCaseFieldNames::cordfield() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestCamelCaseFieldNames.CordField)
  return cordfield_.Get();
}
inline void TestCamelCaseFieldNames::set_cordfield(const ::std::string& value) {
  set_has_cordfield();
  cordfield_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestCamelCaseFieldNames.CordField)
}
#if LANG_CXX11
inline void TestCamelCaseFieldNames::set_cordfield(::std::string&& value) {
  set_has_cordfield();
  cordfield_.Set(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_rvalue:protobuf_unittest.TestCamelCaseFieldNames.CordField)
}
#endif
inline void TestCamelCaseFieldNames::set_cordfield(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_cordfield();
  cordfield_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_char:protobuf_unittest.TestCamelCaseFieldNames.CordField)
}
inline void TestCamelCaseFieldNames::set_cordfield(const char* value,
    size_t size) {
  set_has_cordfield();
  cordfield_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_pointer:protobuf_unittest.TestCamelCaseFieldNames.CordField)
}
inline ::std::string* TestCamelCaseFieldNames::mutable_cordfield() {
  set_has_cordfield();
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestCamelCaseFieldNames.CordField)
  return cordfield_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline ::std::string* TestCamelCaseFieldNames::release_cordfield() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestCamelCaseFieldNames.CordField)
  if (!has_cordfield()) {
    return NULL;
  }
  clear_has_cordfield();
  return cordfield_.ReleaseNonDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline void TestCamelCaseFieldNames::set_allocated_cordfield(::std::string* cordfield) {
  if (cordfield != NULL) {
    set_has_cordfield();
  } else {
    clear_has_cordfield();
  }
  cordfield_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), cordfield,
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestCamelCaseFieldNames.CordField)
}
inline ::std::string* TestCamelCaseFieldNames::unsafe_arena_release_cordfield() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestCamelCaseFieldNames.CordField)
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  clear_has_cordfield();
  return cordfield_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      GetArenaNoVirtual());
}
inline void TestCamelCaseFieldNames::unsafe_arena_set_allocated_cordfield(
    ::std::string* cordfield) {
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (cordfield != NULL) {
    set_has_cordfield();
  } else {
    clear_has_cordfield();
  }
  cordfield_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      cordfield, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf_unittest.TestCamelCaseFieldNames.CordField)
}

// repeated int32 RepeatedPrimitiveField = 7;
inline int TestCamelCaseFieldNames::repeatedprimitivefield_size() const {
  return repeatedprimitivefield_.size();
}
inline void TestCamelCaseFieldNames::clear_repeatedprimitivefield() {
  repeatedprimitivefield_.Clear();
}
inline ::google::protobuf::int32 TestCamelCaseFieldNames::repeatedprimitivefield(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestCamelCaseFieldNames.RepeatedPrimitiveField)
  return repeatedprimitivefield_.Get(index);
}
inline void TestCamelCaseFieldNames::set_repeatedprimitivefield(int index, ::google::protobuf::int32 value) {
  repeatedprimitivefield_.Set(index, value);
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestCamelCaseFieldNames.RepeatedPrimitiveField)
}
inline void TestCamelCaseFieldNames::add_repeatedprimitivefield(::google::protobuf::int32 value) {
  repeatedprimitivefield_.Add(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestCamelCaseFieldNames.RepeatedPrimitiveField)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
TestCamelCaseFieldNames::repeatedprimitivefield() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestCamelCaseFieldNames.RepeatedPrimitiveField)
  return repeatedprimitivefield_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
TestCamelCaseFieldNames::mutable_repeatedprimitivefield() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestCamelCaseFieldNames.RepeatedPrimitiveField)
  return &repeatedprimitivefield_;
}

// repeated string RepeatedStringField = 8;
inline int TestCamelCaseFieldNames::repeatedstringfield_size() const {
  return repeatedstringfield_.size();
}
inline void TestCamelCaseFieldNames::clear_repeatedstringfield() {
  repeatedstringfield_.Clear();
}
inline const ::std::string& TestCamelCaseFieldNames::repeatedstringfield(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestCamelCaseFieldNames.RepeatedStringField)
  return repeatedstringfield_.Get(index);
}
inline ::std::string* TestCamelCaseFieldNames::mutable_repeatedstringfield(int index) {
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestCamelCaseFieldNames.RepeatedStringField)
  return repeatedstringfield_.Mutable(index);
}
inline void TestCamelCaseFieldNames::set_repeatedstringfield(int index, const ::std::string& value) {
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestCamelCaseFieldNames.RepeatedStringField)
  repeatedstringfield_.Mutable(index)->assign(value);
}
#if LANG_CXX11
inline void TestCamelCaseFieldNames::set_repeatedstringfield(int index, ::std::string&& value) {
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestCamelCaseFieldNames.RepeatedStringField)
  repeatedstringfield_.Mutable(index)->assign(std::move(value));
}
#endif
inline void TestCamelCaseFieldNames::set_repeatedstringfield(int index, const char* value) {
  GOOGLE_DCHECK(value != NULL);
  repeatedstringfield_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:protobuf_unittest.TestCamelCaseFieldNames.RepeatedStringField)
}
inline void TestCamelCaseFieldNames::set_repeatedstringfield(int index, const char* value, size_t size) {
  repeatedstringfield_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:protobuf_unittest.TestCamelCaseFieldNames.RepeatedStringField)
}
inline ::std::string* TestCamelCaseFieldNames::add_repeatedstringfield() {
  // @@protoc_insertion_point(field_add_mutable:protobuf_unittest.TestCamelCaseFieldNames.RepeatedStringField)
  return repeatedstringfield_.Add();
}
inline void TestCamelCaseFieldNames::add_repeatedstringfield(const ::std::string& value) {
  repeatedstringfield_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestCamelCaseFieldNames.RepeatedStringField)
}
#if LANG_CXX11
inline void TestCamelCaseFieldNames::add_repeatedstringfield(::std::string&& value) {
  repeatedstringfield_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestCamelCaseFieldNames.RepeatedStringField)
}
#endif
inline void TestCamelCaseFieldNames::add_repeatedstringfield(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  repeatedstringfield_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:protobuf_unittest.TestCamelCaseFieldNames.RepeatedStringField)
}
inline void TestCamelCaseFieldNames::add_repeatedstringfield(const char* value, size_t size) {
  repeatedstringfield_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:protobuf_unittest.TestCamelCaseFieldNames.RepeatedStringField)
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
TestCamelCaseFieldNames::repeatedstringfield() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestCamelCaseFieldNames.RepeatedStringField)
  return repeatedstringfield_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
TestCamelCaseFieldNames::mutable_repeatedstringfield() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestCamelCaseFieldNames.RepeatedStringField)
  return &repeatedstringfield_;
}

// repeated .protobuf_unittest.ForeignEnum RepeatedEnumField = 9;
inline int TestCamelCaseFieldNames::repeatedenumfield_size() const {
  return repeatedenumfield_.size();
}
inline void TestCamelCaseFieldNames::clear_repeatedenumfield() {
  repeatedenumfield_.Clear();
}
inline ::protobuf_unittest::ForeignEnum TestCamelCaseFieldNames::repeatedenumfield(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestCamelCaseFieldNames.RepeatedEnumField)
  return static_cast< ::protobuf_unittest::ForeignEnum >(repeatedenumfield_.Get(index));
}
inline void TestCamelCaseFieldNames::set_repeatedenumfield(int index, ::protobuf_unittest::ForeignEnum value) {
  assert(::protobuf_unittest::ForeignEnum_IsValid(value));
  repeatedenumfield_.Set(index, value);
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestCamelCaseFieldNames.RepeatedEnumField)
}
inline void TestCamelCaseFieldNames::add_repeatedenumfield(::protobuf_unittest::ForeignEnum value) {
  assert(::protobuf_unittest::ForeignEnum_IsValid(value));
  repeatedenumfield_.Add(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestCamelCaseFieldNames.RepeatedEnumField)
}
inline const ::google::protobuf::RepeatedField<int>&
TestCamelCaseFieldNames::repeatedenumfield() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestCamelCaseFieldNames.RepeatedEnumField)
  return repeatedenumfield_;
}
inline ::google::protobuf::RepeatedField<int>*
TestCamelCaseFieldNames::mutable_repeatedenumfield() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestCamelCaseFieldNames.RepeatedEnumField)
  return &repeatedenumfield_;
}

// repeated .protobuf_unittest.ForeignMessage RepeatedMessageField = 10;
inline int TestCamelCaseFieldNames::repeatedmessagefield_size() const {
  return repeatedmessagefield_.size();
}
inline void TestCamelCaseFieldNames::clear_repeatedmessagefield() {
  repeatedmessagefield_.Clear();
}
inline ::protobuf_unittest::ForeignMessage* TestCamelCaseFieldNames::mutable_repeatedmessagefield(int index) {
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestCamelCaseFieldNames.RepeatedMessageField)
  return repeatedmessagefield_.Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::ForeignMessage >*
TestCamelCaseFieldNames::mutable_repeatedmessagefield() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestCamelCaseFieldNames.RepeatedMessageField)
  return &repeatedmessagefield_;
}
inline const ::protobuf_unittest::ForeignMessage& TestCamelCaseFieldNames::repeatedmessagefield(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestCamelCaseFieldNames.RepeatedMessageField)
  return repeatedmessagefield_.Get(index);
}
inline ::protobuf_unittest::ForeignMessage* TestCamelCaseFieldNames::add_repeatedmessagefield() {
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestCamelCaseFieldNames.RepeatedMessageField)
  return repeatedmessagefield_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::ForeignMessage >&
TestCamelCaseFieldNames::repeatedmessagefield() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestCamelCaseFieldNames.RepeatedMessageField)
  return repeatedmessagefield_;
}

// repeated string RepeatedStringPieceField = 11 [ctype = STRING_PIECE];
inline int TestCamelCaseFieldNames::repeatedstringpiecefield_size() const {
  return repeatedstringpiecefield_.size();
}
inline void TestCamelCaseFieldNames::clear_repeatedstringpiecefield() {
  repeatedstringpiecefield_.Clear();
}
inline const ::std::string& TestCamelCaseFieldNames::repeatedstringpiecefield(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestCamelCaseFieldNames.RepeatedStringPieceField)
  return repeatedstringpiecefield_.Get(index);
}
inline ::std::string* TestCamelCaseFieldNames::mutable_repeatedstringpiecefield(int index) {
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestCamelCaseFieldNames.RepeatedStringPieceField)
  return repeatedstringpiecefield_.Mutable(index);
}
inline void TestCamelCaseFieldNames::set_repeatedstringpiecefield(int index, const ::std::string& value) {
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestCamelCaseFieldNames.RepeatedStringPieceField)
  repeatedstringpiecefield_.Mutable(index)->assign(value);
}
#if LANG_CXX11
inline void TestCamelCaseFieldNames::set_repeatedstringpiecefield(int index, ::std::string&& value) {
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestCamelCaseFieldNames.RepeatedStringPieceField)
  repeatedstringpiecefield_.Mutable(index)->assign(std::move(value));
}
#endif
inline void TestCamelCaseFieldNames::set_repeatedstringpiecefield(int index, const char* value) {
  GOOGLE_DCHECK(value != NULL);
  repeatedstringpiecefield_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:protobuf_unittest.TestCamelCaseFieldNames.RepeatedStringPieceField)
}
inline void TestCamelCaseFieldNames::set_repeatedstringpiecefield(int index, const char* value, size_t size) {
  repeatedstringpiecefield_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:protobuf_unittest.TestCamelCaseFieldNames.RepeatedStringPieceField)
}
inline ::std::string* TestCamelCaseFieldNames::add_repeatedstringpiecefield() {
  // @@protoc_insertion_point(field_add_mutable:protobuf_unittest.TestCamelCaseFieldNames.RepeatedStringPieceField)
  return repeatedstringpiecefield_.Add();
}
inline void TestCamelCaseFieldNames::add_repeatedstringpiecefield(const ::std::string& value) {
  repeatedstringpiecefield_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestCamelCaseFieldNames.RepeatedStringPieceField)
}
#if LANG_CXX11
inline void TestCamelCaseFieldNames::add_repeatedstringpiecefield(::std::string&& value) {
  repeatedstringpiecefield_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestCamelCaseFieldNames.RepeatedStringPieceField)
}
#endif
inline void TestCamelCaseFieldNames::add_repeatedstringpiecefield(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  repeatedstringpiecefield_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:protobuf_unittest.TestCamelCaseFieldNames.RepeatedStringPieceField)
}
inline void TestCamelCaseFieldNames::add_repeatedstringpiecefield(const char* value, size_t size) {
  repeatedstringpiecefield_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:protobuf_unittest.TestCamelCaseFieldNames.RepeatedStringPieceField)
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
TestCamelCaseFieldNames::repeatedstringpiecefield() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestCamelCaseFieldNames.RepeatedStringPieceField)
  return repeatedstringpiecefield_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
TestCamelCaseFieldNames::mutable_repeatedstringpiecefield() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestCamelCaseFieldNames.RepeatedStringPieceField)
  return &repeatedstringpiecefield_;
}

// repeated string RepeatedCordField = 12 [ctype = CORD];
inline int TestCamelCaseFieldNames::repeatedcordfield_size() const {
  return repeatedcordfield_.size();
}
inline void TestCamelCaseFieldNames::clear_repeatedcordfield() {
  repeatedcordfield_.Clear();
}
inline const ::std::string& TestCamelCaseFieldNames::repeatedcordfield(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestCamelCaseFieldNames.RepeatedCordField)
  return repeatedcordfield_.Get(index);
}
inline ::std::string* TestCamelCaseFieldNames::mutable_repeatedcordfield(int index) {
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestCamelCaseFieldNames.RepeatedCordField)
  return repeatedcordfield_.Mutable(index);
}
inline void TestCamelCaseFieldNames::set_repeatedcordfield(int index, const ::std::string& value) {
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestCamelCaseFieldNames.RepeatedCordField)
  repeatedcordfield_.Mutable(index)->assign(value);
}
#if LANG_CXX11
inline void TestCamelCaseFieldNames::set_repeatedcordfield(int index, ::std::string&& value) {
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestCamelCaseFieldNames.RepeatedCordField)
  repeatedcordfield_.Mutable(index)->assign(std::move(value));
}
#endif
inline void TestCamelCaseFieldNames::set_repeatedcordfield(int index, const char* value) {
  GOOGLE_DCHECK(value != NULL);
  repeatedcordfield_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:protobuf_unittest.TestCamelCaseFieldNames.RepeatedCordField)
}
inline void TestCamelCaseFieldNames::set_repeatedcordfield(int index, const char* value, size_t size) {
  repeatedcordfield_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:protobuf_unittest.TestCamelCaseFieldNames.RepeatedCordField)
}
inline ::std::string* TestCamelCaseFieldNames::add_repeatedcordfield() {
  // @@protoc_insertion_point(field_add_mutable:protobuf_unittest.TestCamelCaseFieldNames.RepeatedCordField)
  return repeatedcordfield_.Add();
}
inline void TestCamelCaseFieldNames::add_repeatedcordfield(const ::std::string& value) {
  repeatedcordfield_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestCamelCaseFieldNames.RepeatedCordField)
}
#if LANG_CXX11
inline void TestCamelCaseFieldNames::add_repeatedcordfield(::std::string&& value) {
  repeatedcordfield_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestCamelCaseFieldNames.RepeatedCordField)
}
#endif
inline void TestCamelCaseFieldNames::add_repeatedcordfield(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  repeatedcordfield_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:protobuf_unittest.TestCamelCaseFieldNames.RepeatedCordField)
}
inline void TestCamelCaseFieldNames::add_repeatedcordfield(const char* value, size_t size) {
  repeatedcordfield_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:protobuf_unittest.TestCamelCaseFieldNames.RepeatedCordField)
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
TestCamelCaseFieldNames::repeatedcordfield() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestCamelCaseFieldNames.RepeatedCordField)
  return repeatedcordfield_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
TestCamelCaseFieldNames::mutable_repeatedcordfield() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestCamelCaseFieldNames.RepeatedCordField)
  return &repeatedcordfield_;
}

// -------------------------------------------------------------------

// TestFieldOrderings_NestedMessage

// optional int64 oo = 2;
inline bool TestFieldOrderings_NestedMessage::has_oo() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TestFieldOrderings_NestedMessage::set_has_oo() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TestFieldOrderings_NestedMessage::clear_has_oo() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TestFieldOrderings_NestedMessage::clear_oo() {
  oo_ = GOOGLE_LONGLONG(0);
  clear_has_oo();
}
inline ::google::protobuf::int64 TestFieldOrderings_NestedMessage::oo() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestFieldOrderings.NestedMessage.oo)
  return oo_;
}
inline void TestFieldOrderings_NestedMessage::set_oo(::google::protobuf::int64 value) {
  set_has_oo();
  oo_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestFieldOrderings.NestedMessage.oo)
}

// optional int32 bb = 1;
inline bool TestFieldOrderings_NestedMessage::has_bb() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void TestFieldOrderings_NestedMessage::set_has_bb() {
  _has_bits_[0] |= 0x00000002u;
}
inline void TestFieldOrderings_NestedMessage::clear_has_bb() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void TestFieldOrderings_NestedMessage::clear_bb() {
  bb_ = 0;
  clear_has_bb();
}
inline ::google::protobuf::int32 TestFieldOrderings_NestedMessage::bb() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestFieldOrderings.NestedMessage.bb)
  return bb_;
}
inline void TestFieldOrderings_NestedMessage::set_bb(::google::protobuf::int32 value) {
  set_has_bb();
  bb_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestFieldOrderings.NestedMessage.bb)
}

// -------------------------------------------------------------------

// TestFieldOrderings

// optional string my_string = 11;
inline bool TestFieldOrderings::has_my_string() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TestFieldOrderings::set_has_my_string() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TestFieldOrderings::clear_has_my_string() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TestFieldOrderings::clear_my_string() {
  my_string_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
  clear_has_my_string();
}
inline const ::std::string& TestFieldOrderings::my_string() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestFieldOrderings.my_string)
  return my_string_.Get();
}
inline void TestFieldOrderings::set_my_string(const ::std::string& value) {
  set_has_my_string();
  my_string_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestFieldOrderings.my_string)
}
#if LANG_CXX11
inline void TestFieldOrderings::set_my_string(::std::string&& value) {
  set_has_my_string();
  my_string_.Set(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_rvalue:protobuf_unittest.TestFieldOrderings.my_string)
}
#endif
inline void TestFieldOrderings::set_my_string(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_my_string();
  my_string_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_char:protobuf_unittest.TestFieldOrderings.my_string)
}
inline void TestFieldOrderings::set_my_string(const char* value,
    size_t size) {
  set_has_my_string();
  my_string_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_pointer:protobuf_unittest.TestFieldOrderings.my_string)
}
inline ::std::string* TestFieldOrderings::mutable_my_string() {
  set_has_my_string();
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestFieldOrderings.my_string)
  return my_string_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline ::std::string* TestFieldOrderings::release_my_string() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestFieldOrderings.my_string)
  if (!has_my_string()) {
    return NULL;
  }
  clear_has_my_string();
  return my_string_.ReleaseNonDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline void TestFieldOrderings::set_allocated_my_string(::std::string* my_string) {
  if (my_string != NULL) {
    set_has_my_string();
  } else {
    clear_has_my_string();
  }
  my_string_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), my_string,
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestFieldOrderings.my_string)
}
inline ::std::string* TestFieldOrderings::unsafe_arena_release_my_string() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestFieldOrderings.my_string)
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  clear_has_my_string();
  return my_string_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      GetArenaNoVirtual());
}
inline void TestFieldOrderings::unsafe_arena_set_allocated_my_string(
    ::std::string* my_string) {
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (my_string != NULL) {
    set_has_my_string();
  } else {
    clear_has_my_string();
  }
  my_string_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      my_string, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf_unittest.TestFieldOrderings.my_string)
}

// optional int64 my_int = 1;
inline bool TestFieldOrderings::has_my_int() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void TestFieldOrderings::set_has_my_int() {
  _has_bits_[0] |= 0x00000004u;
}
inline void TestFieldOrderings::clear_has_my_int() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void TestFieldOrderings::clear_my_int() {
  my_int_ = GOOGLE_LONGLONG(0);
  clear_has_my_int();
}
inline ::google::protobuf::int64 TestFieldOrderings::my_int() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestFieldOrderings.my_int)
  return my_int_;
}
inline void TestFieldOrderings::set_my_int(::google::protobuf::int64 value) {
  set_has_my_int();
  my_int_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestFieldOrderings.my_int)
}

// optional float my_float = 101;
inline bool TestFieldOrderings::has_my_float() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void TestFieldOrderings::set_has_my_float() {
  _has_bits_[0] |= 0x00000008u;
}
inline void TestFieldOrderings::clear_has_my_float() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void TestFieldOrderings::clear_my_float() {
  my_float_ = 0;
  clear_has_my_float();
}
inline float TestFieldOrderings::my_float() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestFieldOrderings.my_float)
  return my_float_;
}
inline void TestFieldOrderings::set_my_float(float value) {
  set_has_my_float();
  my_float_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestFieldOrderings.my_float)
}

// optional .protobuf_unittest.TestFieldOrderings.NestedMessage optional_nested_message = 200;
inline bool TestFieldOrderings::has_optional_nested_message() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void TestFieldOrderings::set_has_optional_nested_message() {
  _has_bits_[0] |= 0x00000002u;
}
inline void TestFieldOrderings::clear_has_optional_nested_message() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void TestFieldOrderings::clear_optional_nested_message() {
  if (optional_nested_message_ != NULL) optional_nested_message_->Clear();
  clear_has_optional_nested_message();
}
inline const ::protobuf_unittest::TestFieldOrderings_NestedMessage& TestFieldOrderings::_internal_optional_nested_message() const {
  return *optional_nested_message_;
}
inline const ::protobuf_unittest::TestFieldOrderings_NestedMessage& TestFieldOrderings::optional_nested_message() const {
  const ::protobuf_unittest::TestFieldOrderings_NestedMessage* p = optional_nested_message_;
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestFieldOrderings.optional_nested_message)
  return p != NULL ? *p : *reinterpret_cast<const ::protobuf_unittest::TestFieldOrderings_NestedMessage*>(
      &::protobuf_unittest::_TestFieldOrderings_NestedMessage_default_instance_);
}
inline ::protobuf_unittest::TestFieldOrderings_NestedMessage* TestFieldOrderings::release_optional_nested_message() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestFieldOrderings.optional_nested_message)
  clear_has_optional_nested_message();
  ::protobuf_unittest::TestFieldOrderings_NestedMessage* temp = optional_nested_message_;
  if (GetArenaNoVirtual() != NULL) {
    temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
  }
  optional_nested_message_ = NULL;
  return temp;
}
inline ::protobuf_unittest::TestFieldOrderings_NestedMessage* TestFieldOrderings::unsafe_arena_release_optional_nested_message() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestFieldOrderings.optional_nested_message)
  clear_has_optional_nested_message();
  ::protobuf_unittest::TestFieldOrderings_NestedMessage* temp = optional_nested_message_;
  optional_nested_message_ = NULL;
  return temp;
}
inline ::protobuf_unittest::TestFieldOrderings_NestedMessage* TestFieldOrderings::mutable_optional_nested_message() {
  set_has_optional_nested_message();
  if (optional_nested_message_ == NULL) {
    auto* p = CreateMaybeMessage<::protobuf_unittest::TestFieldOrderings_NestedMessage>(GetArenaNoVirtual());
    optional_nested_message_ = p;
  }
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestFieldOrderings.optional_nested_message)
  return optional_nested_message_;
}
inline void TestFieldOrderings::set_allocated_optional_nested_message(::protobuf_unittest::TestFieldOrderings_NestedMessage* optional_nested_message) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete optional_nested_message_;
  }
  if (optional_nested_message) {
    ::google::protobuf::Arena* submessage_arena =
      ::google::protobuf::Arena::GetArena(optional_nested_message);
    if (message_arena != submessage_arena) {
      optional_nested_message = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, optional_nested_message, submessage_arena);
    }
    set_has_optional_nested_message();
  } else {
    clear_has_optional_nested_message();
  }
  optional_nested_message_ = optional_nested_message;
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestFieldOrderings.optional_nested_message)
}

// -------------------------------------------------------------------

// TestExtensionOrderings1

// optional string my_string = 1;
inline bool TestExtensionOrderings1::has_my_string() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TestExtensionOrderings1::set_has_my_string() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TestExtensionOrderings1::clear_has_my_string() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TestExtensionOrderings1::clear_my_string() {
  my_string_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
  clear_has_my_string();
}
inline const ::std::string& TestExtensionOrderings1::my_string() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestExtensionOrderings1.my_string)
  return my_string_.Get();
}
inline void TestExtensionOrderings1::set_my_string(const ::std::string& value) {
  set_has_my_string();
  my_string_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestExtensionOrderings1.my_string)
}
#if LANG_CXX11
inline void TestExtensionOrderings1::set_my_string(::std::string&& value) {
  set_has_my_string();
  my_string_.Set(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_rvalue:protobuf_unittest.TestExtensionOrderings1.my_string)
}
#endif
inline void TestExtensionOrderings1::set_my_string(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_my_string();
  my_string_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_char:protobuf_unittest.TestExtensionOrderings1.my_string)
}
inline void TestExtensionOrderings1::set_my_string(const char* value,
    size_t size) {
  set_has_my_string();
  my_string_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_pointer:protobuf_unittest.TestExtensionOrderings1.my_string)
}
inline ::std::string* TestExtensionOrderings1::mutable_my_string() {
  set_has_my_string();
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestExtensionOrderings1.my_string)
  return my_string_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline ::std::string* TestExtensionOrderings1::release_my_string() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestExtensionOrderings1.my_string)
  if (!has_my_string()) {
    return NULL;
  }
  clear_has_my_string();
  return my_string_.ReleaseNonDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline void TestExtensionOrderings1::set_allocated_my_string(::std::string* my_string) {
  if (my_string != NULL) {
    set_has_my_string();
  } else {
    clear_has_my_string();
  }
  my_string_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), my_string,
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestExtensionOrderings1.my_string)
}
inline ::std::string* TestExtensionOrderings1::unsafe_arena_release_my_string() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestExtensionOrderings1.my_string)
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  clear_has_my_string();
  return my_string_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      GetArenaNoVirtual());
}
inline void TestExtensionOrderings1::unsafe_arena_set_allocated_my_string(
    ::std::string* my_string) {
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (my_string != NULL) {
    set_has_my_string();
  } else {
    clear_has_my_string();
  }
  my_string_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      my_string, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf_unittest.TestExtensionOrderings1.my_string)
}

// -------------------------------------------------------------------

// TestExtensionOrderings2_TestExtensionOrderings3

// optional string my_string = 1;
inline bool TestExtensionOrderings2_TestExtensionOrderings3::has_my_string() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TestExtensionOrderings2_TestExtensionOrderings3::set_has_my_string() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TestExtensionOrderings2_TestExtensionOrderings3::clear_has_my_string() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TestExtensionOrderings2_TestExtensionOrderings3::clear_my_string() {
  my_string_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
  clear_has_my_string();
}
inline const ::std::string& TestExtensionOrderings2_TestExtensionOrderings3::my_string() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestExtensionOrderings2.TestExtensionOrderings3.my_string)
  return my_string_.Get();
}
inline void TestExtensionOrderings2_TestExtensionOrderings3::set_my_string(const ::std::string& value) {
  set_has_my_string();
  my_string_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestExtensionOrderings2.TestExtensionOrderings3.my_string)
}
#if LANG_CXX11
inline void TestExtensionOrderings2_TestExtensionOrderings3::set_my_string(::std::string&& value) {
  set_has_my_string();
  my_string_.Set(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_rvalue:protobuf_unittest.TestExtensionOrderings2.TestExtensionOrderings3.my_string)
}
#endif
inline void TestExtensionOrderings2_TestExtensionOrderings3::set_my_string(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_my_string();
  my_string_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_char:protobuf_unittest.TestExtensionOrderings2.TestExtensionOrderings3.my_string)
}
inline void TestExtensionOrderings2_TestExtensionOrderings3::set_my_string(const char* value,
    size_t size) {
  set_has_my_string();
  my_string_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_pointer:protobuf_unittest.TestExtensionOrderings2.TestExtensionOrderings3.my_string)
}
inline ::std::string* TestExtensionOrderings2_TestExtensionOrderings3::mutable_my_string() {
  set_has_my_string();
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestExtensionOrderings2.TestExtensionOrderings3.my_string)
  return my_string_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline ::std::string* TestExtensionOrderings2_TestExtensionOrderings3::release_my_string() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestExtensionOrderings2.TestExtensionOrderings3.my_string)
  if (!has_my_string()) {
    return NULL;
  }
  clear_has_my_string();
  return my_string_.ReleaseNonDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline void TestExtensionOrderings2_TestExtensionOrderings3::set_allocated_my_string(::std::string* my_string) {
  if (my_string != NULL) {
    set_has_my_string();
  } else {
    clear_has_my_string();
  }
  my_string_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), my_string,
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestExtensionOrderings2.TestExtensionOrderings3.my_string)
}
inline ::std::string* TestExtensionOrderings2_TestExtensionOrderings3::unsafe_arena_release_my_string() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestExtensionOrderings2.TestExtensionOrderings3.my_string)
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  clear_has_my_string();
  return my_string_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      GetArenaNoVirtual());
}
inline void TestExtensionOrderings2_TestExtensionOrderings3::unsafe_arena_set_allocated_my_string(
    ::std::string* my_string) {
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (my_string != NULL) {
    set_has_my_string();
  } else {
    clear_has_my_string();
  }
  my_string_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      my_string, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf_unittest.TestExtensionOrderings2.TestExtensionOrderings3.my_string)
}

// -------------------------------------------------------------------

// TestExtensionOrderings2

// optional string my_string = 1;
inline bool TestExtensionOrderings2::has_my_string() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TestExtensionOrderings2::set_has_my_string() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TestExtensionOrderings2::clear_has_my_string() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TestExtensionOrderings2::clear_my_string() {
  my_string_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
  clear_has_my_string();
}
inline const ::std::string& TestExtensionOrderings2::my_string() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestExtensionOrderings2.my_string)
  return my_string_.Get();
}
inline void TestExtensionOrderings2::set_my_string(const ::std::string& value) {
  set_has_my_string();
  my_string_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestExtensionOrderings2.my_string)
}
#if LANG_CXX11
inline void TestExtensionOrderings2::set_my_string(::std::string&& value) {
  set_has_my_string();
  my_string_.Set(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_rvalue:protobuf_unittest.TestExtensionOrderings2.my_string)
}
#endif
inline void TestExtensionOrderings2::set_my_string(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_my_string();
  my_string_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_char:protobuf_unittest.TestExtensionOrderings2.my_string)
}
inline void TestExtensionOrderings2::set_my_string(const char* value,
    size_t size) {
  set_has_my_string();
  my_string_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_pointer:protobuf_unittest.TestExtensionOrderings2.my_string)
}
inline ::std::string* TestExtensionOrderings2::mutable_my_string() {
  set_has_my_string();
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestExtensionOrderings2.my_string)
  return my_string_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline ::std::string* TestExtensionOrderings2::release_my_string() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestExtensionOrderings2.my_string)
  if (!has_my_string()) {
    return NULL;
  }
  clear_has_my_string();
  return my_string_.ReleaseNonDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline void TestExtensionOrderings2::set_allocated_my_string(::std::string* my_string) {
  if (my_string != NULL) {
    set_has_my_string();
  } else {
    clear_has_my_string();
  }
  my_string_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), my_string,
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestExtensionOrderings2.my_string)
}
inline ::std::string* TestExtensionOrderings2::unsafe_arena_release_my_string() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestExtensionOrderings2.my_string)
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  clear_has_my_string();
  return my_string_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      GetArenaNoVirtual());
}
inline void TestExtensionOrderings2::unsafe_arena_set_allocated_my_string(
    ::std::string* my_string) {
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (my_string != NULL) {
    set_has_my_string();
  } else {
    clear_has_my_string();
  }
  my_string_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      my_string, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf_unittest.TestExtensionOrderings2.my_string)
}

// -------------------------------------------------------------------

// TestExtremeDefaultValues

// optional bytes escaped_bytes = 1 [default = "\000\001\007\010\014\n\r\t\013\\\'\"\376"];
inline bool TestExtremeDefaultValues::has_escaped_bytes() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TestExtremeDefaultValues::set_has_escaped_bytes() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TestExtremeDefaultValues::clear_has_escaped_bytes() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TestExtremeDefaultValues::clear_escaped_bytes() {
  escaped_bytes_.ClearToDefault(&::protobuf_unittest::TestExtremeDefaultValues::_i_give_permission_to_break_this_code_default_escaped_bytes_.get(), GetArenaNoVirtual());
  clear_has_escaped_bytes();
}
inline const ::std::string& TestExtremeDefaultValues::escaped_bytes() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestExtremeDefaultValues.escaped_bytes)
  return escaped_bytes_.Get();
}
inline void TestExtremeDefaultValues::set_escaped_bytes(const ::std::string& value) {
  set_has_escaped_bytes();
  escaped_bytes_.Set(&::protobuf_unittest::TestExtremeDefaultValues::_i_give_permission_to_break_this_code_default_escaped_bytes_.get(), value, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestExtremeDefaultValues.escaped_bytes)
}
#if LANG_CXX11
inline void TestExtremeDefaultValues::set_escaped_bytes(::std::string&& value) {
  set_has_escaped_bytes();
  escaped_bytes_.Set(
    &::protobuf_unittest::TestExtremeDefaultValues::_i_give_permission_to_break_this_code_default_escaped_bytes_.get(), ::std::move(value), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_rvalue:protobuf_unittest.TestExtremeDefaultValues.escaped_bytes)
}
#endif
inline void TestExtremeDefaultValues::set_escaped_bytes(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_escaped_bytes();
  escaped_bytes_.Set(&::protobuf_unittest::TestExtremeDefaultValues::_i_give_permission_to_break_this_code_default_escaped_bytes_.get(), ::std::string(value),
              GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_char:protobuf_unittest.TestExtremeDefaultValues.escaped_bytes)
}
inline void TestExtremeDefaultValues::set_escaped_bytes(const void* value,
    size_t size) {
  set_has_escaped_bytes();
  escaped_bytes_.Set(&::protobuf_unittest::TestExtremeDefaultValues::_i_give_permission_to_break_this_code_default_escaped_bytes_.get(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_pointer:protobuf_unittest.TestExtremeDefaultValues.escaped_bytes)
}
inline ::std::string* TestExtremeDefaultValues::mutable_escaped_bytes() {
  set_has_escaped_bytes();
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestExtremeDefaultValues.escaped_bytes)
  return escaped_bytes_.Mutable(&::protobuf_unittest::TestExtremeDefaultValues::_i_give_permission_to_break_this_code_default_escaped_bytes_.get(), GetArenaNoVirtual());
}
inline ::std::string* TestExtremeDefaultValues::release_escaped_bytes() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestExtremeDefaultValues.escaped_bytes)
  if (!has_escaped_bytes()) {
    return NULL;
  }
  clear_has_escaped_bytes();
  return escaped_bytes_.ReleaseNonDefault(&::protobuf_unittest::TestExtremeDefaultValues::_i_give_permission_to_break_this_code_default_escaped_bytes_.get(), GetArenaNoVirtual());
}
inline void TestExtremeDefaultValues::set_allocated_escaped_bytes(::std::string* escaped_bytes) {
  if (escaped_bytes != NULL) {
    set_has_escaped_bytes();
  } else {
    clear_has_escaped_bytes();
  }
  escaped_bytes_.SetAllocated(&::protobuf_unittest::TestExtremeDefaultValues::_i_give_permission_to_break_this_code_default_escaped_bytes_.get(), escaped_bytes,
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestExtremeDefaultValues.escaped_bytes)
}
inline ::std::string* TestExtremeDefaultValues::unsafe_arena_release_escaped_bytes() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestExtremeDefaultValues.escaped_bytes)
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  clear_has_escaped_bytes();
  return escaped_bytes_.UnsafeArenaRelease(&::protobuf_unittest::TestExtremeDefaultValues::_i_give_permission_to_break_this_code_default_escaped_bytes_.get(),
      GetArenaNoVirtual());
}
inline void TestExtremeDefaultValues::unsafe_arena_set_allocated_escaped_bytes(
    ::std::string* escaped_bytes) {
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (escaped_bytes != NULL) {
    set_has_escaped_bytes();
  } else {
    clear_has_escaped_bytes();
  }
  escaped_bytes_.UnsafeArenaSetAllocated(&::protobuf_unittest::TestExtremeDefaultValues::_i_give_permission_to_break_this_code_default_escaped_bytes_.get(),
      escaped_bytes, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf_unittest.TestExtremeDefaultValues.escaped_bytes)
}

// optional uint32 large_uint32 = 2 [default = 4294967295];
inline bool TestExtremeDefaultValues::has_large_uint32() const {
  return (_has_bits_[0] & 0x00000400u) != 0;
}
inline void TestExtremeDefaultValues::set_has_large_uint32() {
  _has_bits_[0] |= 0x00000400u;
}
inline void TestExtremeDefaultValues::clear_has_large_uint32() {
  _has_bits_[0] &= ~0x00000400u;
}
inline void TestExtremeDefaultValues::clear_large_uint32() {
  large_uint32_ = 4294967295u;
  clear_has_large_uint32();
}
inline ::google::protobuf::uint32 TestExtremeDefaultValues::large_uint32() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestExtremeDefaultValues.large_uint32)
  return large_uint32_;
}
inline void TestExtremeDefaultValues::set_large_uint32(::google::protobuf::uint32 value) {
  set_has_large_uint32();
  large_uint32_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestExtremeDefaultValues.large_uint32)
}

// optional uint64 large_uint64 = 3 [default = 18446744073709551615];
inline bool TestExtremeDefaultValues::has_large_uint64() const {
  return (_has_bits_[0] & 0x00000200u) != 0;
}
inline void TestExtremeDefaultValues::set_has_large_uint64() {
  _has_bits_[0] |= 0x00000200u;
}
inline void TestExtremeDefaultValues::clear_has_large_uint64() {
  _has_bits_[0] &= ~0x00000200u;
}
inline void TestExtremeDefaultValues::clear_large_uint64() {
  large_uint64_ = GOOGLE_ULONGLONG(18446744073709551615);
  clear_has_large_uint64();
}
inline ::google::protobuf::uint64 TestExtremeDefaultValues::large_uint64() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestExtremeDefaultValues.large_uint64)
  return large_uint64_;
}
inline void TestExtremeDefaultValues::set_large_uint64(::google::protobuf::uint64 value) {
  set_has_large_uint64();
  large_uint64_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestExtremeDefaultValues.large_uint64)
}

// optional int32 small_int32 = 4 [default = -2147483647];
inline bool TestExtremeDefaultValues::has_small_int32() const {
  return (_has_bits_[0] & 0x00000800u) != 0;
}
inline void TestExtremeDefaultValues::set_has_small_int32() {
  _has_bits_[0] |= 0x00000800u;
}
inline void TestExtremeDefaultValues::clear_has_small_int32() {
  _has_bits_[0] &= ~0x00000800u;
}
inline void TestExtremeDefaultValues::clear_small_int32() {
  small_int32_ = -2147483647;
  clear_has_small_int32();
}
inline ::google::protobuf::int32 TestExtremeDefaultValues::small_int32() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestExtremeDefaultValues.small_int32)
  return small_int32_;
}
inline void TestExtremeDefaultValues::set_small_int32(::google::protobuf::int32 value) {
  set_has_small_int32();
  small_int32_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestExtremeDefaultValues.small_int32)
}

// optional int64 small_int64 = 5 [default = -9223372036854775807];
inline bool TestExtremeDefaultValues::has_small_int64() const {
  return (_has_bits_[0] & 0x00001000u) != 0;
}
inline void TestExtremeDefaultValues::set_has_small_int64() {
  _has_bits_[0] |= 0x00001000u;
}
inline void TestExtremeDefaultValues::clear_has_small_int64() {
  _has_bits_[0] &= ~0x00001000u;
}
inline void TestExtremeDefaultValues::clear_small_int64() {
  small_int64_ = GOOGLE_LONGLONG(-9223372036854775807);
  clear_has_small_int64();
}
inline ::google::protobuf::int64 TestExtremeDefaultValues::small_int64() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestExtremeDefaultValues.small_int64)
  return small_int64_;
}
inline void TestExtremeDefaultValues::set_small_int64(::google::protobuf::int64 value) {
  set_has_small_int64();
  small_int64_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestExtremeDefaultValues.small_int64)
}

// optional int32 really_small_int32 = 21 [default = -2147483648];
inline bool TestExtremeDefaultValues::has_really_small_int32() const {
  return (_has_bits_[0] & 0x02000000u) != 0;
}
inline void TestExtremeDefaultValues::set_has_really_small_int32() {
  _has_bits_[0] |= 0x02000000u;
}
inline void TestExtremeDefaultValues::clear_has_really_small_int32() {
  _has_bits_[0] &= ~0x02000000u;
}
inline void TestExtremeDefaultValues::clear_really_small_int32() {
  really_small_int32_ = (~0x7fffffff);
  clear_has_really_small_int32();
}
inline ::google::protobuf::int32 TestExtremeDefaultValues::really_small_int32() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestExtremeDefaultValues.really_small_int32)
  return really_small_int32_;
}
inline void TestExtremeDefaultValues::set_really_small_int32(::google::protobuf::int32 value) {
  set_has_really_small_int32();
  really_small_int32_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestExtremeDefaultValues.really_small_int32)
}

// optional int64 really_small_int64 = 22 [default = -9223372036854775808];
inline bool TestExtremeDefaultValues::has_really_small_int64() const {
  return (_has_bits_[0] & 0x04000000u) != 0;
}
inline void TestExtremeDefaultValues::set_has_really_small_int64() {
  _has_bits_[0] |= 0x04000000u;
}
inline void TestExtremeDefaultValues::clear_has_really_small_int64() {
  _has_bits_[0] &= ~0x04000000u;
}
inline void TestExtremeDefaultValues::clear_really_small_int64() {
  really_small_int64_ = GOOGLE_LONGLONG(~0x7fffffffffffffff);
  clear_has_really_small_int64();
}
inline ::google::protobuf::int64 TestExtremeDefaultValues::really_small_int64() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestExtremeDefaultValues.really_small_int64)
  return really_small_int64_;
}
inline void TestExtremeDefaultValues::set_really_small_int64(::google::protobuf::int64 value) {
  set_has_really_small_int64();
  really_small_int64_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestExtremeDefaultValues.really_small_int64)
}

// optional string utf8_string = 6 [default = "\341\210\264"];
inline bool TestExtremeDefaultValues::has_utf8_string() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void TestExtremeDefaultValues::set_has_utf8_string() {
  _has_bits_[0] |= 0x00000002u;
}
inline void TestExtremeDefaultValues::clear_has_utf8_string() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void TestExtremeDefaultValues::clear_utf8_string() {
  utf8_string_.ClearToDefault(&::protobuf_unittest::TestExtremeDefaultValues::_i_give_permission_to_break_this_code_default_utf8_string_.get(), GetArenaNoVirtual());
  clear_has_utf8_string();
}
inline const ::std::string& TestExtremeDefaultValues::utf8_string() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestExtremeDefaultValues.utf8_string)
  return utf8_string_.Get();
}
inline void TestExtremeDefaultValues::set_utf8_string(const ::std::string& value) {
  set_has_utf8_string();
  utf8_string_.Set(&::protobuf_unittest::TestExtremeDefaultValues::_i_give_permission_to_break_this_code_default_utf8_string_.get(), value, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestExtremeDefaultValues.utf8_string)
}
#if LANG_CXX11
inline void TestExtremeDefaultValues::set_utf8_string(::std::string&& value) {
  set_has_utf8_string();
  utf8_string_.Set(
    &::protobuf_unittest::TestExtremeDefaultValues::_i_give_permission_to_break_this_code_default_utf8_string_.get(), ::std::move(value), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_rvalue:protobuf_unittest.TestExtremeDefaultValues.utf8_string)
}
#endif
inline void TestExtremeDefaultValues::set_utf8_string(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_utf8_string();
  utf8_string_.Set(&::protobuf_unittest::TestExtremeDefaultValues::_i_give_permission_to_break_this_code_default_utf8_string_.get(), ::std::string(value),
              GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_char:protobuf_unittest.TestExtremeDefaultValues.utf8_string)
}
inline void TestExtremeDefaultValues::set_utf8_string(const char* value,
    size_t size) {
  set_has_utf8_string();
  utf8_string_.Set(&::protobuf_unittest::TestExtremeDefaultValues::_i_give_permission_to_break_this_code_default_utf8_string_.get(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_pointer:protobuf_unittest.TestExtremeDefaultValues.utf8_string)
}
inline ::std::string* TestExtremeDefaultValues::mutable_utf8_string() {
  set_has_utf8_string();
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestExtremeDefaultValues.utf8_string)
  return utf8_string_.Mutable(&::protobuf_unittest::TestExtremeDefaultValues::_i_give_permission_to_break_this_code_default_utf8_string_.get(), GetArenaNoVirtual());
}
inline ::std::string* TestExtremeDefaultValues::release_utf8_string() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestExtremeDefaultValues.utf8_string)
  if (!has_utf8_string()) {
    return NULL;
  }
  clear_has_utf8_string();
  return utf8_string_.ReleaseNonDefault(&::protobuf_unittest::TestExtremeDefaultValues::_i_give_permission_to_break_this_code_default_utf8_string_.get(), GetArenaNoVirtual());
}
inline void TestExtremeDefaultValues::set_allocated_utf8_string(::std::string* utf8_string) {
  if (utf8_string != NULL) {
    set_has_utf8_string();
  } else {
    clear_has_utf8_string();
  }
  utf8_string_.SetAllocated(&::protobuf_unittest::TestExtremeDefaultValues::_i_give_permission_to_break_this_code_default_utf8_string_.get(), utf8_string,
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestExtremeDefaultValues.utf8_string)
}
inline ::std::string* TestExtremeDefaultValues::unsafe_arena_release_utf8_string() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestExtremeDefaultValues.utf8_string)
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  clear_has_utf8_string();
  return utf8_string_.UnsafeArenaRelease(&::protobuf_unittest::TestExtremeDefaultValues::_i_give_permission_to_break_this_code_default_utf8_string_.get(),
      GetArenaNoVirtual());
}
inline void TestExtremeDefaultValues::unsafe_arena_set_allocated_utf8_string(
    ::std::string* utf8_string) {
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (utf8_string != NULL) {
    set_has_utf8_string();
  } else {
    clear_has_utf8_string();
  }
  utf8_string_.UnsafeArenaSetAllocated(&::protobuf_unittest::TestExtremeDefaultValues::_i_give_permission_to_break_this_code_default_utf8_string_.get(),
      utf8_string, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf_unittest.TestExtremeDefaultValues.utf8_string)
}

// optional float zero_float = 7 [default = 0];
inline bool TestExtremeDefaultValues::has_zero_float() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void TestExtremeDefaultValues::set_has_zero_float() {
  _has_bits_[0] |= 0x00000100u;
}
inline void TestExtremeDefaultValues::clear_has_zero_float() {
  _has_bits_[0] &= ~0x00000100u;
}
inline void TestExtremeDefaultValues::clear_zero_float() {
  zero_float_ = 0;
  clear_has_zero_float();
}
inline float TestExtremeDefaultValues::zero_float() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestExtremeDefaultValues.zero_float)
  return zero_float_;
}
inline void TestExtremeDefaultValues::set_zero_float(float value) {
  set_has_zero_float();
  zero_float_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestExtremeDefaultValues.zero_float)
}

// optional float one_float = 8 [default = 1];
inline bool TestExtremeDefaultValues::has_one_float() const {
  return (_has_bits_[0] & 0x00002000u) != 0;
}
inline void TestExtremeDefaultValues::set_has_one_float() {
  _has_bits_[0] |= 0x00002000u;
}
inline void TestExtremeDefaultValues::clear_has_one_float() {
  _has_bits_[0] &= ~0x00002000u;
}
inline void TestExtremeDefaultValues::clear_one_float() {
  one_float_ = 1;
  clear_has_one_float();
}
inline float TestExtremeDefaultValues::one_float() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestExtremeDefaultValues.one_float)
  return one_float_;
}
inline void TestExtremeDefaultValues::set_one_float(float value) {
  set_has_one_float();
  one_float_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestExtremeDefaultValues.one_float)
}

// optional float small_float = 9 [default = 1.5];
inline bool TestExtremeDefaultValues::has_small_float() const {
  return (_has_bits_[0] & 0x00004000u) != 0;
}
inline void TestExtremeDefaultValues::set_has_small_float() {
  _has_bits_[0] |= 0x00004000u;
}
inline void TestExtremeDefaultValues::clear_has_small_float() {
  _has_bits_[0] &= ~0x00004000u;
}
inline void TestExtremeDefaultValues::clear_small_float() {
  small_float_ = 1.5f;
  clear_has_small_float();
}
inline float TestExtremeDefaultValues::small_float() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestExtremeDefaultValues.small_float)
  return small_float_;
}
inline void TestExtremeDefaultValues::set_small_float(float value) {
  set_has_small_float();
  small_float_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestExtremeDefaultValues.small_float)
}

// optional float negative_one_float = 10 [default = -1];
inline bool TestExtremeDefaultValues::has_negative_one_float() const {
  return (_has_bits_[0] & 0x00008000u) != 0;
}
inline void TestExtremeDefaultValues::set_has_negative_one_float() {
  _has_bits_[0] |= 0x00008000u;
}
inline void TestExtremeDefaultValues::clear_has_negative_one_float() {
  _has_bits_[0] &= ~0x00008000u;
}
inline void TestExtremeDefaultValues::clear_negative_one_float() {
  negative_one_float_ = -1;
  clear_has_negative_one_float();
}
inline float TestExtremeDefaultValues::negative_one_float() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestExtremeDefaultValues.negative_one_float)
  return negative_one_float_;
}
inline void TestExtremeDefaultValues::set_negative_one_float(float value) {
  set_has_negative_one_float();
  negative_one_float_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestExtremeDefaultValues.negative_one_float)
}

// optional float negative_float = 11 [default = -1.5];
inline bool TestExtremeDefaultValues::has_negative_float() const {
  return (_has_bits_[0] & 0x00010000u) != 0;
}
inline void TestExtremeDefaultValues::set_has_negative_float() {
  _has_bits_[0] |= 0x00010000u;
}
inline void TestExtremeDefaultValues::clear_has_negative_float() {
  _has_bits_[0] &= ~0x00010000u;
}
inline void TestExtremeDefaultValues::clear_negative_float() {
  negative_float_ = -1.5f;
  clear_has_negative_float();
}
inline float TestExtremeDefaultValues::negative_float() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestExtremeDefaultValues.negative_float)
  return negative_float_;
}
inline void TestExtremeDefaultValues::set_negative_float(float value) {
  set_has_negative_float();
  negative_float_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestExtremeDefaultValues.negative_float)
}

// optional float large_float = 12 [default = 2e+08];
inline bool TestExtremeDefaultValues::has_large_float() const {
  return (_has_bits_[0] & 0x00020000u) != 0;
}
inline void TestExtremeDefaultValues::set_has_large_float() {
  _has_bits_[0] |= 0x00020000u;
}
inline void TestExtremeDefaultValues::clear_has_large_float() {
  _has_bits_[0] &= ~0x00020000u;
}
inline void TestExtremeDefaultValues::clear_large_float() {
  large_float_ = 2e+08f;
  clear_has_large_float();
}
inline float TestExtremeDefaultValues::large_float() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestExtremeDefaultValues.large_float)
  return large_float_;
}
inline void TestExtremeDefaultValues::set_large_float(float value) {
  set_has_large_float();
  large_float_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestExtremeDefaultValues.large_float)
}

// optional float small_negative_float = 13 [default = -8e-28];
inline bool TestExtremeDefaultValues::has_small_negative_float() const {
  return (_has_bits_[0] & 0x00040000u) != 0;
}
inline void TestExtremeDefaultValues::set_has_small_negative_float() {
  _has_bits_[0] |= 0x00040000u;
}
inline void TestExtremeDefaultValues::clear_has_small_negative_float() {
  _has_bits_[0] &= ~0x00040000u;
}
inline void TestExtremeDefaultValues::clear_small_negative_float() {
  small_negative_float_ = -8e-28f;
  clear_has_small_negative_float();
}
inline float TestExtremeDefaultValues::small_negative_float() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestExtremeDefaultValues.small_negative_float)
  return small_negative_float_;
}
inline void TestExtremeDefaultValues::set_small_negative_float(float value) {
  set_has_small_negative_float();
  small_negative_float_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestExtremeDefaultValues.small_negative_float)
}

// optional double inf_double = 14 [default = inf];
inline bool TestExtremeDefaultValues::has_inf_double() const {
  return (_has_bits_[0] & 0x00080000u) != 0;
}
inline void TestExtremeDefaultValues::set_has_inf_double() {
  _has_bits_[0] |= 0x00080000u;
}
inline void TestExtremeDefaultValues::clear_has_inf_double() {
  _has_bits_[0] &= ~0x00080000u;
}
inline void TestExtremeDefaultValues::clear_inf_double() {
  inf_double_ = ::google::protobuf::internal::Infinity();
  clear_has_inf_double();
}
inline double TestExtremeDefaultValues::inf_double() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestExtremeDefaultValues.inf_double)
  return inf_double_;
}
inline void TestExtremeDefaultValues::set_inf_double(double value) {
  set_has_inf_double();
  inf_double_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestExtremeDefaultValues.inf_double)
}

// optional double neg_inf_double = 15 [default = -inf];
inline bool TestExtremeDefaultValues::has_neg_inf_double() const {
  return (_has_bits_[0] & 0x00100000u) != 0;
}
inline void TestExtremeDefaultValues::set_has_neg_inf_double() {
  _has_bits_[0] |= 0x00100000u;
}
inline void TestExtremeDefaultValues::clear_has_neg_inf_double() {
  _has_bits_[0] &= ~0x00100000u;
}
inline void TestExtremeDefaultValues::clear_neg_inf_double() {
  neg_inf_double_ = -::google::protobuf::internal::Infinity();
  clear_has_neg_inf_double();
}
inline double TestExtremeDefaultValues::neg_inf_double() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestExtremeDefaultValues.neg_inf_double)
  return neg_inf_double_;
}
inline void TestExtremeDefaultValues::set_neg_inf_double(double value) {
  set_has_neg_inf_double();
  neg_inf_double_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestExtremeDefaultValues.neg_inf_double)
}

// optional double nan_double = 16 [default = nan];
inline bool TestExtremeDefaultValues::has_nan_double() const {
  return (_has_bits_[0] & 0x00200000u) != 0;
}
inline void TestExtremeDefaultValues::set_has_nan_double() {
  _has_bits_[0] |= 0x00200000u;
}
inline void TestExtremeDefaultValues::clear_has_nan_double() {
  _has_bits_[0] &= ~0x00200000u;
}
inline void TestExtremeDefaultValues::clear_nan_double() {
  nan_double_ = ::google::protobuf::internal::NaN();
  clear_has_nan_double();
}
inline double TestExtremeDefaultValues::nan_double() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestExtremeDefaultValues.nan_double)
  return nan_double_;
}
inline void TestExtremeDefaultValues::set_nan_double(double value) {
  set_has_nan_double();
  nan_double_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestExtremeDefaultValues.nan_double)
}

// optional float inf_float = 17 [default = inf];
inline bool TestExtremeDefaultValues::has_inf_float() const {
  return (_has_bits_[0] & 0x00400000u) != 0;
}
inline void TestExtremeDefaultValues::set_has_inf_float() {
  _has_bits_[0] |= 0x00400000u;
}
inline void TestExtremeDefaultValues::clear_has_inf_float() {
  _has_bits_[0] &= ~0x00400000u;
}
inline void TestExtremeDefaultValues::clear_inf_float() {
  inf_float_ = static_cast<float>(::google::protobuf::internal::Infinity());
  clear_has_inf_float();
}
inline float TestExtremeDefaultValues::inf_float() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestExtremeDefaultValues.inf_float)
  return inf_float_;
}
inline void TestExtremeDefaultValues::set_inf_float(float value) {
  set_has_inf_float();
  inf_float_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestExtremeDefaultValues.inf_float)
}

// optional float neg_inf_float = 18 [default = -inf];
inline bool TestExtremeDefaultValues::has_neg_inf_float() const {
  return (_has_bits_[0] & 0x00800000u) != 0;
}
inline void TestExtremeDefaultValues::set_has_neg_inf_float() {
  _has_bits_[0] |= 0x00800000u;
}
inline void TestExtremeDefaultValues::clear_has_neg_inf_float() {
  _has_bits_[0] &= ~0x00800000u;
}
inline void TestExtremeDefaultValues::clear_neg_inf_float() {
  neg_inf_float_ = static_cast<float>(-::google::protobuf::internal::Infinity());
  clear_has_neg_inf_float();
}
inline float TestExtremeDefaultValues::neg_inf_float() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestExtremeDefaultValues.neg_inf_float)
  return neg_inf_float_;
}
inline void TestExtremeDefaultValues::set_neg_inf_float(float value) {
  set_has_neg_inf_float();
  neg_inf_float_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestExtremeDefaultValues.neg_inf_float)
}

// optional float nan_float = 19 [default = nan];
inline bool TestExtremeDefaultValues::has_nan_float() const {
  return (_has_bits_[0] & 0x01000000u) != 0;
}
inline void TestExtremeDefaultValues::set_has_nan_float() {
  _has_bits_[0] |= 0x01000000u;
}
inline void TestExtremeDefaultValues::clear_has_nan_float() {
  _has_bits_[0] &= ~0x01000000u;
}
inline void TestExtremeDefaultValues::clear_nan_float() {
  nan_float_ = static_cast<float>(::google::protobuf::internal::NaN());
  clear_has_nan_float();
}
inline float TestExtremeDefaultValues::nan_float() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestExtremeDefaultValues.nan_float)
  return nan_float_;
}
inline void TestExtremeDefaultValues::set_nan_float(float value) {
  set_has_nan_float();
  nan_float_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestExtremeDefaultValues.nan_float)
}

// optional string cpp_trigraph = 20 [default = "? ? ?? ?? ??? ??/ ??-"];
inline bool TestExtremeDefaultValues::has_cpp_trigraph() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void TestExtremeDefaultValues::set_has_cpp_trigraph() {
  _has_bits_[0] |= 0x00000004u;
}
inline void TestExtremeDefaultValues::clear_has_cpp_trigraph() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void TestExtremeDefaultValues::clear_cpp_trigraph() {
  cpp_trigraph_.ClearToDefault(&::protobuf_unittest::TestExtremeDefaultValues::_i_give_permission_to_break_this_code_default_cpp_trigraph_.get(), GetArenaNoVirtual());
  clear_has_cpp_trigraph();
}
inline const ::std::string& TestExtremeDefaultValues::cpp_trigraph() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestExtremeDefaultValues.cpp_trigraph)
  return cpp_trigraph_.Get();
}
inline void TestExtremeDefaultValues::set_cpp_trigraph(const ::std::string& value) {
  set_has_cpp_trigraph();
  cpp_trigraph_.Set(&::protobuf_unittest::TestExtremeDefaultValues::_i_give_permission_to_break_this_code_default_cpp_trigraph_.get(), value, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestExtremeDefaultValues.cpp_trigraph)
}
#if LANG_CXX11
inline void TestExtremeDefaultValues::set_cpp_trigraph(::std::string&& value) {
  set_has_cpp_trigraph();
  cpp_trigraph_.Set(
    &::protobuf_unittest::TestExtremeDefaultValues::_i_give_permission_to_break_this_code_default_cpp_trigraph_.get(), ::std::move(value), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_rvalue:protobuf_unittest.TestExtremeDefaultValues.cpp_trigraph)
}
#endif
inline void TestExtremeDefaultValues::set_cpp_trigraph(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_cpp_trigraph();
  cpp_trigraph_.Set(&::protobuf_unittest::TestExtremeDefaultValues::_i_give_permission_to_break_this_code_default_cpp_trigraph_.get(), ::std::string(value),
              GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_char:protobuf_unittest.TestExtremeDefaultValues.cpp_trigraph)
}
inline void TestExtremeDefaultValues::set_cpp_trigraph(const char* value,
    size_t size) {
  set_has_cpp_trigraph();
  cpp_trigraph_.Set(&::protobuf_unittest::TestExtremeDefaultValues::_i_give_permission_to_break_this_code_default_cpp_trigraph_.get(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_pointer:protobuf_unittest.TestExtremeDefaultValues.cpp_trigraph)
}
inline ::std::string* TestExtremeDefaultValues::mutable_cpp_trigraph() {
  set_has_cpp_trigraph();
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestExtremeDefaultValues.cpp_trigraph)
  return cpp_trigraph_.Mutable(&::protobuf_unittest::TestExtremeDefaultValues::_i_give_permission_to_break_this_code_default_cpp_trigraph_.get(), GetArenaNoVirtual());
}
inline ::std::string* TestExtremeDefaultValues::release_cpp_trigraph() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestExtremeDefaultValues.cpp_trigraph)
  if (!has_cpp_trigraph()) {
    return NULL;
  }
  clear_has_cpp_trigraph();
  return cpp_trigraph_.ReleaseNonDefault(&::protobuf_unittest::TestExtremeDefaultValues::_i_give_permission_to_break_this_code_default_cpp_trigraph_.get(), GetArenaNoVirtual());
}
inline void TestExtremeDefaultValues::set_allocated_cpp_trigraph(::std::string* cpp_trigraph) {
  if (cpp_trigraph != NULL) {
    set_has_cpp_trigraph();
  } else {
    clear_has_cpp_trigraph();
  }
  cpp_trigraph_.SetAllocated(&::protobuf_unittest::TestExtremeDefaultValues::_i_give_permission_to_break_this_code_default_cpp_trigraph_.get(), cpp_trigraph,
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestExtremeDefaultValues.cpp_trigraph)
}
inline ::std::string* TestExtremeDefaultValues::unsafe_arena_release_cpp_trigraph() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestExtremeDefaultValues.cpp_trigraph)
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  clear_has_cpp_trigraph();
  return cpp_trigraph_.UnsafeArenaRelease(&::protobuf_unittest::TestExtremeDefaultValues::_i_give_permission_to_break_this_code_default_cpp_trigraph_.get(),
      GetArenaNoVirtual());
}
inline void TestExtremeDefaultValues::unsafe_arena_set_allocated_cpp_trigraph(
    ::std::string* cpp_trigraph) {
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (cpp_trigraph != NULL) {
    set_has_cpp_trigraph();
  } else {
    clear_has_cpp_trigraph();
  }
  cpp_trigraph_.UnsafeArenaSetAllocated(&::protobuf_unittest::TestExtremeDefaultValues::_i_give_permission_to_break_this_code_default_cpp_trigraph_.get(),
      cpp_trigraph, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf_unittest.TestExtremeDefaultValues.cpp_trigraph)
}

// optional string string_with_zero = 23 [default = "hel\000lo"];
inline bool TestExtremeDefaultValues::has_string_with_zero() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void TestExtremeDefaultValues::set_has_string_with_zero() {
  _has_bits_[0] |= 0x00000008u;
}
inline void TestExtremeDefaultValues::clear_has_string_with_zero() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void TestExtremeDefaultValues::clear_string_with_zero() {
  string_with_zero_.ClearToDefault(&::protobuf_unittest::TestExtremeDefaultValues::_i_give_permission_to_break_this_code_default_string_with_zero_.get(), GetArenaNoVirtual());
  clear_has_string_with_zero();
}
inline const ::std::string& TestExtremeDefaultValues::string_with_zero() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestExtremeDefaultValues.string_with_zero)
  return string_with_zero_.Get();
}
inline void TestExtremeDefaultValues::set_string_with_zero(const ::std::string& value) {
  set_has_string_with_zero();
  string_with_zero_.Set(&::protobuf_unittest::TestExtremeDefaultValues::_i_give_permission_to_break_this_code_default_string_with_zero_.get(), value, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestExtremeDefaultValues.string_with_zero)
}
#if LANG_CXX11
inline void TestExtremeDefaultValues::set_string_with_zero(::std::string&& value) {
  set_has_string_with_zero();
  string_with_zero_.Set(
    &::protobuf_unittest::TestExtremeDefaultValues::_i_give_permission_to_break_this_code_default_string_with_zero_.get(), ::std::move(value), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_rvalue:protobuf_unittest.TestExtremeDefaultValues.string_with_zero)
}
#endif
inline void TestExtremeDefaultValues::set_string_with_zero(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_string_with_zero();
  string_with_zero_.Set(&::protobuf_unittest::TestExtremeDefaultValues::_i_give_permission_to_break_this_code_default_string_with_zero_.get(), ::std::string(value),
              GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_char:protobuf_unittest.TestExtremeDefaultValues.string_with_zero)
}
inline void TestExtremeDefaultValues::set_string_with_zero(const char* value,
    size_t size) {
  set_has_string_with_zero();
  string_with_zero_.Set(&::protobuf_unittest::TestExtremeDefaultValues::_i_give_permission_to_break_this_code_default_string_with_zero_.get(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_pointer:protobuf_unittest.TestExtremeDefaultValues.string_with_zero)
}
inline ::std::string* TestExtremeDefaultValues::mutable_string_with_zero() {
  set_has_string_with_zero();
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestExtremeDefaultValues.string_with_zero)
  return string_with_zero_.Mutable(&::protobuf_unittest::TestExtremeDefaultValues::_i_give_permission_to_break_this_code_default_string_with_zero_.get(), GetArenaNoVirtual());
}
inline ::std::string* TestExtremeDefaultValues::release_string_with_zero() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestExtremeDefaultValues.string_with_zero)
  if (!has_string_with_zero()) {
    return NULL;
  }
  clear_has_string_with_zero();
  return string_with_zero_.ReleaseNonDefault(&::protobuf_unittest::TestExtremeDefaultValues::_i_give_permission_to_break_this_code_default_string_with_zero_.get(), GetArenaNoVirtual());
}
inline void TestExtremeDefaultValues::set_allocated_string_with_zero(::std::string* string_with_zero) {
  if (string_with_zero != NULL) {
    set_has_string_with_zero();
  } else {
    clear_has_string_with_zero();
  }
  string_with_zero_.SetAllocated(&::protobuf_unittest::TestExtremeDefaultValues::_i_give_permission_to_break_this_code_default_string_with_zero_.get(), string_with_zero,
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestExtremeDefaultValues.string_with_zero)
}
inline ::std::string* TestExtremeDefaultValues::unsafe_arena_release_string_with_zero() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestExtremeDefaultValues.string_with_zero)
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  clear_has_string_with_zero();
  return string_with_zero_.UnsafeArenaRelease(&::protobuf_unittest::TestExtremeDefaultValues::_i_give_permission_to_break_this_code_default_string_with_zero_.get(),
      GetArenaNoVirtual());
}
inline void TestExtremeDefaultValues::unsafe_arena_set_allocated_string_with_zero(
    ::std::string* string_with_zero) {
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (string_with_zero != NULL) {
    set_has_string_with_zero();
  } else {
    clear_has_string_with_zero();
  }
  string_with_zero_.UnsafeArenaSetAllocated(&::protobuf_unittest::TestExtremeDefaultValues::_i_give_permission_to_break_this_code_default_string_with_zero_.get(),
      string_with_zero, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf_unittest.TestExtremeDefaultValues.string_with_zero)
}

// optional bytes bytes_with_zero = 24 [default = "wor\000ld"];
inline bool TestExtremeDefaultValues::has_bytes_with_zero() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void TestExtremeDefaultValues::set_has_bytes_with_zero() {
  _has_bits_[0] |= 0x00000010u;
}
inline void TestExtremeDefaultValues::clear_has_bytes_with_zero() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void TestExtremeDefaultValues::clear_bytes_with_zero() {
  bytes_with_zero_.ClearToDefault(&::protobuf_unittest::TestExtremeDefaultValues::_i_give_permission_to_break_this_code_default_bytes_with_zero_.get(), GetArenaNoVirtual());
  clear_has_bytes_with_zero();
}
inline const ::std::string& TestExtremeDefaultValues::bytes_with_zero() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestExtremeDefaultValues.bytes_with_zero)
  return bytes_with_zero_.Get();
}
inline void TestExtremeDefaultValues::set_bytes_with_zero(const ::std::string& value) {
  set_has_bytes_with_zero();
  bytes_with_zero_.Set(&::protobuf_unittest::TestExtremeDefaultValues::_i_give_permission_to_break_this_code_default_bytes_with_zero_.get(), value, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestExtremeDefaultValues.bytes_with_zero)
}
#if LANG_CXX11
inline void TestExtremeDefaultValues::set_bytes_with_zero(::std::string&& value) {
  set_has_bytes_with_zero();
  bytes_with_zero_.Set(
    &::protobuf_unittest::TestExtremeDefaultValues::_i_give_permission_to_break_this_code_default_bytes_with_zero_.get(), ::std::move(value), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_rvalue:protobuf_unittest.TestExtremeDefaultValues.bytes_with_zero)
}
#endif
inline void TestExtremeDefaultValues::set_bytes_with_zero(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_bytes_with_zero();
  bytes_with_zero_.Set(&::protobuf_unittest::TestExtremeDefaultValues::_i_give_permission_to_break_this_code_default_bytes_with_zero_.get(), ::std::string(value),
              GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_char:protobuf_unittest.TestExtremeDefaultValues.bytes_with_zero)
}
inline void TestExtremeDefaultValues::set_bytes_with_zero(const void* value,
    size_t size) {
  set_has_bytes_with_zero();
  bytes_with_zero_.Set(&::protobuf_unittest::TestExtremeDefaultValues::_i_give_permission_to_break_this_code_default_bytes_with_zero_.get(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_pointer:protobuf_unittest.TestExtremeDefaultValues.bytes_with_zero)
}
inline ::std::string* TestExtremeDefaultValues::mutable_bytes_with_zero() {
  set_has_bytes_with_zero();
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestExtremeDefaultValues.bytes_with_zero)
  return bytes_with_zero_.Mutable(&::protobuf_unittest::TestExtremeDefaultValues::_i_give_permission_to_break_this_code_default_bytes_with_zero_.get(), GetArenaNoVirtual());
}
inline ::std::string* TestExtremeDefaultValues::release_bytes_with_zero() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestExtremeDefaultValues.bytes_with_zero)
  if (!has_bytes_with_zero()) {
    return NULL;
  }
  clear_has_bytes_with_zero();
  return bytes_with_zero_.ReleaseNonDefault(&::protobuf_unittest::TestExtremeDefaultValues::_i_give_permission_to_break_this_code_default_bytes_with_zero_.get(), GetArenaNoVirtual());
}
inline void TestExtremeDefaultValues::set_allocated_bytes_with_zero(::std::string* bytes_with_zero) {
  if (bytes_with_zero != NULL) {
    set_has_bytes_with_zero();
  } else {
    clear_has_bytes_with_zero();
  }
  bytes_with_zero_.SetAllocated(&::protobuf_unittest::TestExtremeDefaultValues::_i_give_permission_to_break_this_code_default_bytes_with_zero_.get(), bytes_with_zero,
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestExtremeDefaultValues.bytes_with_zero)
}
inline ::std::string* TestExtremeDefaultValues::unsafe_arena_release_bytes_with_zero() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestExtremeDefaultValues.bytes_with_zero)
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  clear_has_bytes_with_zero();
  return bytes_with_zero_.UnsafeArenaRelease(&::protobuf_unittest::TestExtremeDefaultValues::_i_give_permission_to_break_this_code_default_bytes_with_zero_.get(),
      GetArenaNoVirtual());
}
inline void TestExtremeDefaultValues::unsafe_arena_set_allocated_bytes_with_zero(
    ::std::string* bytes_with_zero) {
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (bytes_with_zero != NULL) {
    set_has_bytes_with_zero();
  } else {
    clear_has_bytes_with_zero();
  }
  bytes_with_zero_.UnsafeArenaSetAllocated(&::protobuf_unittest::TestExtremeDefaultValues::_i_give_permission_to_break_this_code_default_bytes_with_zero_.get(),
      bytes_with_zero, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf_unittest.TestExtremeDefaultValues.bytes_with_zero)
}

// optional string string_piece_with_zero = 25 [default = "ab\000c", ctype = STRING_PIECE];
inline bool TestExtremeDefaultValues::has_string_piece_with_zero() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void TestExtremeDefaultValues::set_has_string_piece_with_zero() {
  _has_bits_[0] |= 0x00000020u;
}
inline void TestExtremeDefaultValues::clear_has_string_piece_with_zero() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void TestExtremeDefaultValues::clear_string_piece_with_zero() {
  string_piece_with_zero_.ClearToDefault(&::protobuf_unittest::TestExtremeDefaultValues::_i_give_permission_to_break_this_code_default_string_piece_with_zero_.get(), GetArenaNoVirtual());
  clear_has_string_piece_with_zero();
}
inline const ::std::string& TestExtremeDefaultValues::string_piece_with_zero() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestExtremeDefaultValues.string_piece_with_zero)
  return string_piece_with_zero_.Get();
}
inline void TestExtremeDefaultValues::set_string_piece_with_zero(const ::std::string& value) {
  set_has_string_piece_with_zero();
  string_piece_with_zero_.Set(&::protobuf_unittest::TestExtremeDefaultValues::_i_give_permission_to_break_this_code_default_string_piece_with_zero_.get(), value, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestExtremeDefaultValues.string_piece_with_zero)
}
#if LANG_CXX11
inline void TestExtremeDefaultValues::set_string_piece_with_zero(::std::string&& value) {
  set_has_string_piece_with_zero();
  string_piece_with_zero_.Set(
    &::protobuf_unittest::TestExtremeDefaultValues::_i_give_permission_to_break_this_code_default_string_piece_with_zero_.get(), ::std::move(value), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_rvalue:protobuf_unittest.TestExtremeDefaultValues.string_piece_with_zero)
}
#endif
inline void TestExtremeDefaultValues::set_string_piece_with_zero(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_string_piece_with_zero();
  string_piece_with_zero_.Set(&::protobuf_unittest::TestExtremeDefaultValues::_i_give_permission_to_break_this_code_default_string_piece_with_zero_.get(), ::std::string(value),
              GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_char:protobuf_unittest.TestExtremeDefaultValues.string_piece_with_zero)
}
inline void TestExtremeDefaultValues::set_string_piece_with_zero(const char* value,
    size_t size) {
  set_has_string_piece_with_zero();
  string_piece_with_zero_.Set(&::protobuf_unittest::TestExtremeDefaultValues::_i_give_permission_to_break_this_code_default_string_piece_with_zero_.get(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_pointer:protobuf_unittest.TestExtremeDefaultValues.string_piece_with_zero)
}
inline ::std::string* TestExtremeDefaultValues::mutable_string_piece_with_zero() {
  set_has_string_piece_with_zero();
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestExtremeDefaultValues.string_piece_with_zero)
  return string_piece_with_zero_.Mutable(&::protobuf_unittest::TestExtremeDefaultValues::_i_give_permission_to_break_this_code_default_string_piece_with_zero_.get(), GetArenaNoVirtual());
}
inline ::std::string* TestExtremeDefaultValues::release_string_piece_with_zero() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestExtremeDefaultValues.string_piece_with_zero)
  if (!has_string_piece_with_zero()) {
    return NULL;
  }
  clear_has_string_piece_with_zero();
  return string_piece_with_zero_.ReleaseNonDefault(&::protobuf_unittest::TestExtremeDefaultValues::_i_give_permission_to_break_this_code_default_string_piece_with_zero_.get(), GetArenaNoVirtual());
}
inline void TestExtremeDefaultValues::set_allocated_string_piece_with_zero(::std::string* string_piece_with_zero) {
  if (string_piece_with_zero != NULL) {
    set_has_string_piece_with_zero();
  } else {
    clear_has_string_piece_with_zero();
  }
  string_piece_with_zero_.SetAllocated(&::protobuf_unittest::TestExtremeDefaultValues::_i_give_permission_to_break_this_code_default_string_piece_with_zero_.get(), string_piece_with_zero,
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestExtremeDefaultValues.string_piece_with_zero)
}
inline ::std::string* TestExtremeDefaultValues::unsafe_arena_release_string_piece_with_zero() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestExtremeDefaultValues.string_piece_with_zero)
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  clear_has_string_piece_with_zero();
  return string_piece_with_zero_.UnsafeArenaRelease(&::protobuf_unittest::TestExtremeDefaultValues::_i_give_permission_to_break_this_code_default_string_piece_with_zero_.get(),
      GetArenaNoVirtual());
}
inline void TestExtremeDefaultValues::unsafe_arena_set_allocated_string_piece_with_zero(
    ::std::string* string_piece_with_zero) {
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (string_piece_with_zero != NULL) {
    set_has_string_piece_with_zero();
  } else {
    clear_has_string_piece_with_zero();
  }
  string_piece_with_zero_.UnsafeArenaSetAllocated(&::protobuf_unittest::TestExtremeDefaultValues::_i_give_permission_to_break_this_code_default_string_piece_with_zero_.get(),
      string_piece_with_zero, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf_unittest.TestExtremeDefaultValues.string_piece_with_zero)
}

// optional string cord_with_zero = 26 [default = "12\0003", ctype = CORD];
inline bool TestExtremeDefaultValues::has_cord_with_zero() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void TestExtremeDefaultValues::set_has_cord_with_zero() {
  _has_bits_[0] |= 0x00000040u;
}
inline void TestExtremeDefaultValues::clear_has_cord_with_zero() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void TestExtremeDefaultValues::clear_cord_with_zero() {
  cord_with_zero_.ClearToDefault(&::protobuf_unittest::TestExtremeDefaultValues::_i_give_permission_to_break_this_code_default_cord_with_zero_.get(), GetArenaNoVirtual());
  clear_has_cord_with_zero();
}
inline const ::std::string& TestExtremeDefaultValues::cord_with_zero() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestExtremeDefaultValues.cord_with_zero)
  return cord_with_zero_.Get();
}
inline void TestExtremeDefaultValues::set_cord_with_zero(const ::std::string& value) {
  set_has_cord_with_zero();
  cord_with_zero_.Set(&::protobuf_unittest::TestExtremeDefaultValues::_i_give_permission_to_break_this_code_default_cord_with_zero_.get(), value, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestExtremeDefaultValues.cord_with_zero)
}
#if LANG_CXX11
inline void TestExtremeDefaultValues::set_cord_with_zero(::std::string&& value) {
  set_has_cord_with_zero();
  cord_with_zero_.Set(
    &::protobuf_unittest::TestExtremeDefaultValues::_i_give_permission_to_break_this_code_default_cord_with_zero_.get(), ::std::move(value), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_rvalue:protobuf_unittest.TestExtremeDefaultValues.cord_with_zero)
}
#endif
inline void TestExtremeDefaultValues::set_cord_with_zero(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_cord_with_zero();
  cord_with_zero_.Set(&::protobuf_unittest::TestExtremeDefaultValues::_i_give_permission_to_break_this_code_default_cord_with_zero_.get(), ::std::string(value),
              GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_char:protobuf_unittest.TestExtremeDefaultValues.cord_with_zero)
}
inline void TestExtremeDefaultValues::set_cord_with_zero(const char* value,
    size_t size) {
  set_has_cord_with_zero();
  cord_with_zero_.Set(&::protobuf_unittest::TestExtremeDefaultValues::_i_give_permission_to_break_this_code_default_cord_with_zero_.get(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_pointer:protobuf_unittest.TestExtremeDefaultValues.cord_with_zero)
}
inline ::std::string* TestExtremeDefaultValues::mutable_cord_with_zero() {
  set_has_cord_with_zero();
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestExtremeDefaultValues.cord_with_zero)
  return cord_with_zero_.Mutable(&::protobuf_unittest::TestExtremeDefaultValues::_i_give_permission_to_break_this_code_default_cord_with_zero_.get(), GetArenaNoVirtual());
}
inline ::std::string* TestExtremeDefaultValues::release_cord_with_zero() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestExtremeDefaultValues.cord_with_zero)
  if (!has_cord_with_zero()) {
    return NULL;
  }
  clear_has_cord_with_zero();
  return cord_with_zero_.ReleaseNonDefault(&::protobuf_unittest::TestExtremeDefaultValues::_i_give_permission_to_break_this_code_default_cord_with_zero_.get(), GetArenaNoVirtual());
}
inline void TestExtremeDefaultValues::set_allocated_cord_with_zero(::std::string* cord_with_zero) {
  if (cord_with_zero != NULL) {
    set_has_cord_with_zero();
  } else {
    clear_has_cord_with_zero();
  }
  cord_with_zero_.SetAllocated(&::protobuf_unittest::TestExtremeDefaultValues::_i_give_permission_to_break_this_code_default_cord_with_zero_.get(), cord_with_zero,
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestExtremeDefaultValues.cord_with_zero)
}
inline ::std::string* TestExtremeDefaultValues::unsafe_arena_release_cord_with_zero() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestExtremeDefaultValues.cord_with_zero)
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  clear_has_cord_with_zero();
  return cord_with_zero_.UnsafeArenaRelease(&::protobuf_unittest::TestExtremeDefaultValues::_i_give_permission_to_break_this_code_default_cord_with_zero_.get(),
      GetArenaNoVirtual());
}
inline void TestExtremeDefaultValues::unsafe_arena_set_allocated_cord_with_zero(
    ::std::string* cord_with_zero) {
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (cord_with_zero != NULL) {
    set_has_cord_with_zero();
  } else {
    clear_has_cord_with_zero();
  }
  cord_with_zero_.UnsafeArenaSetAllocated(&::protobuf_unittest::TestExtremeDefaultValues::_i_give_permission_to_break_this_code_default_cord_with_zero_.get(),
      cord_with_zero, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf_unittest.TestExtremeDefaultValues.cord_with_zero)
}

// optional string replacement_string = 27 [default = "${unknown}"];
inline bool TestExtremeDefaultValues::has_replacement_string() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void TestExtremeDefaultValues::set_has_replacement_string() {
  _has_bits_[0] |= 0x00000080u;
}
inline void TestExtremeDefaultValues::clear_has_replacement_string() {
  _has_bits_[0] &= ~0x00000080u;
}
inline void TestExtremeDefaultValues::clear_replacement_string() {
  replacement_string_.ClearToDefault(&::protobuf_unittest::TestExtremeDefaultValues::_i_give_permission_to_break_this_code_default_replacement_string_.get(), GetArenaNoVirtual());
  clear_has_replacement_string();
}
inline const ::std::string& TestExtremeDefaultValues::replacement_string() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestExtremeDefaultValues.replacement_string)
  return replacement_string_.Get();
}
inline void TestExtremeDefaultValues::set_replacement_string(const ::std::string& value) {
  set_has_replacement_string();
  replacement_string_.Set(&::protobuf_unittest::TestExtremeDefaultValues::_i_give_permission_to_break_this_code_default_replacement_string_.get(), value, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestExtremeDefaultValues.replacement_string)
}
#if LANG_CXX11
inline void TestExtremeDefaultValues::set_replacement_string(::std::string&& value) {
  set_has_replacement_string();
  replacement_string_.Set(
    &::protobuf_unittest::TestExtremeDefaultValues::_i_give_permission_to_break_this_code_default_replacement_string_.get(), ::std::move(value), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_rvalue:protobuf_unittest.TestExtremeDefaultValues.replacement_string)
}
#endif
inline void TestExtremeDefaultValues::set_replacement_string(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_replacement_string();
  replacement_string_.Set(&::protobuf_unittest::TestExtremeDefaultValues::_i_give_permission_to_break_this_code_default_replacement_string_.get(), ::std::string(value),
              GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_char:protobuf_unittest.TestExtremeDefaultValues.replacement_string)
}
inline void TestExtremeDefaultValues::set_replacement_string(const char* value,
    size_t size) {
  set_has_replacement_string();
  replacement_string_.Set(&::protobuf_unittest::TestExtremeDefaultValues::_i_give_permission_to_break_this_code_default_replacement_string_.get(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_pointer:protobuf_unittest.TestExtremeDefaultValues.replacement_string)
}
inline ::std::string* TestExtremeDefaultValues::mutable_replacement_string() {
  set_has_replacement_string();
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestExtremeDefaultValues.replacement_string)
  return replacement_string_.Mutable(&::protobuf_unittest::TestExtremeDefaultValues::_i_give_permission_to_break_this_code_default_replacement_string_.get(), GetArenaNoVirtual());
}
inline ::std::string* TestExtremeDefaultValues::release_replacement_string() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestExtremeDefaultValues.replacement_string)
  if (!has_replacement_string()) {
    return NULL;
  }
  clear_has_replacement_string();
  return replacement_string_.ReleaseNonDefault(&::protobuf_unittest::TestExtremeDefaultValues::_i_give_permission_to_break_this_code_default_replacement_string_.get(), GetArenaNoVirtual());
}
inline void TestExtremeDefaultValues::set_allocated_replacement_string(::std::string* replacement_string) {
  if (replacement_string != NULL) {
    set_has_replacement_string();
  } else {
    clear_has_replacement_string();
  }
  replacement_string_.SetAllocated(&::protobuf_unittest::TestExtremeDefaultValues::_i_give_permission_to_break_this_code_default_replacement_string_.get(), replacement_string,
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestExtremeDefaultValues.replacement_string)
}
inline ::std::string* TestExtremeDefaultValues::unsafe_arena_release_replacement_string() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestExtremeDefaultValues.replacement_string)
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  clear_has_replacement_string();
  return replacement_string_.UnsafeArenaRelease(&::protobuf_unittest::TestExtremeDefaultValues::_i_give_permission_to_break_this_code_default_replacement_string_.get(),
      GetArenaNoVirtual());
}
inline void TestExtremeDefaultValues::unsafe_arena_set_allocated_replacement_string(
    ::std::string* replacement_string) {
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (replacement_string != NULL) {
    set_has_replacement_string();
  } else {
    clear_has_replacement_string();
  }
  replacement_string_.UnsafeArenaSetAllocated(&::protobuf_unittest::TestExtremeDefaultValues::_i_give_permission_to_break_this_code_default_replacement_string_.get(),
      replacement_string, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf_unittest.TestExtremeDefaultValues.replacement_string)
}

// -------------------------------------------------------------------

// SparseEnumMessage

// optional .protobuf_unittest.TestSparseEnum sparse_enum = 1;
inline bool SparseEnumMessage::has_sparse_enum() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void SparseEnumMessage::set_has_sparse_enum() {
  _has_bits_[0] |= 0x00000001u;
}
inline void SparseEnumMessage::clear_has_sparse_enum() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void SparseEnumMessage::clear_sparse_enum() {
  sparse_enum_ = 123;
  clear_has_sparse_enum();
}
inline ::protobuf_unittest::TestSparseEnum SparseEnumMessage::sparse_enum() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.SparseEnumMessage.sparse_enum)
  return static_cast< ::protobuf_unittest::TestSparseEnum >(sparse_enum_);
}
inline void SparseEnumMessage::set_sparse_enum(::protobuf_unittest::TestSparseEnum value) {
  assert(::protobuf_unittest::TestSparseEnum_IsValid(value));
  set_has_sparse_enum();
  sparse_enum_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.SparseEnumMessage.sparse_enum)
}

// -------------------------------------------------------------------

// OneString

// optional string data = 1;
inline bool OneString::has_data() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void OneString::set_has_data() {
  _has_bits_[0] |= 0x00000001u;
}
inline void OneString::clear_has_data() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void OneString::clear_data() {
  data_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
  clear_has_data();
}
inline const ::std::string& OneString::data() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.OneString.data)
  return data_.Get();
}
inline void OneString::set_data(const ::std::string& value) {
  set_has_data();
  data_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set:protobuf_unittest.OneString.data)
}
#if LANG_CXX11
inline void OneString::set_data(::std::string&& value) {
  set_has_data();
  data_.Set(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_rvalue:protobuf_unittest.OneString.data)
}
#endif
inline void OneString::set_data(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_data();
  data_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_char:protobuf_unittest.OneString.data)
}
inline void OneString::set_data(const char* value,
    size_t size) {
  set_has_data();
  data_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_pointer:protobuf_unittest.OneString.data)
}
inline ::std::string* OneString::mutable_data() {
  set_has_data();
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.OneString.data)
  return data_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline ::std::string* OneString::release_data() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.OneString.data)
  if (!has_data()) {
    return NULL;
  }
  clear_has_data();
  return data_.ReleaseNonDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline void OneString::set_allocated_data(::std::string* data) {
  if (data != NULL) {
    set_has_data();
  } else {
    clear_has_data();
  }
  data_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), data,
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.OneString.data)
}
inline ::std::string* OneString::unsafe_arena_release_data() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.OneString.data)
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  clear_has_data();
  return data_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      GetArenaNoVirtual());
}
inline void OneString::unsafe_arena_set_allocated_data(
    ::std::string* data) {
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (data != NULL) {
    set_has_data();
  } else {
    clear_has_data();
  }
  data_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      data, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf_unittest.OneString.data)
}

// -------------------------------------------------------------------

// MoreString

// repeated string data = 1;
inline int MoreString::data_size() const {
  return data_.size();
}
inline void MoreString::clear_data() {
  data_.Clear();
}
inline const ::std::string& MoreString::data(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.MoreString.data)
  return data_.Get(index);
}
inline ::std::string* MoreString::mutable_data(int index) {
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.MoreString.data)
  return data_.Mutable(index);
}
inline void MoreString::set_data(int index, const ::std::string& value) {
  // @@protoc_insertion_point(field_set:protobuf_unittest.MoreString.data)
  data_.Mutable(index)->assign(value);
}
#if LANG_CXX11
inline void MoreString::set_data(int index, ::std::string&& value) {
  // @@protoc_insertion_point(field_set:protobuf_unittest.MoreString.data)
  data_.Mutable(index)->assign(std::move(value));
}
#endif
inline void MoreString::set_data(int index, const char* value) {
  GOOGLE_DCHECK(value != NULL);
  data_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:protobuf_unittest.MoreString.data)
}
inline void MoreString::set_data(int index, const char* value, size_t size) {
  data_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:protobuf_unittest.MoreString.data)
}
inline ::std::string* MoreString::add_data() {
  // @@protoc_insertion_point(field_add_mutable:protobuf_unittest.MoreString.data)
  return data_.Add();
}
inline void MoreString::add_data(const ::std::string& value) {
  data_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest.MoreString.data)
}
#if LANG_CXX11
inline void MoreString::add_data(::std::string&& value) {
  data_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:protobuf_unittest.MoreString.data)
}
#endif
inline void MoreString::add_data(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  data_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:protobuf_unittest.MoreString.data)
}
inline void MoreString::add_data(const char* value, size_t size) {
  data_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:protobuf_unittest.MoreString.data)
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
MoreString::data() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.MoreString.data)
  return data_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
MoreString::mutable_data() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.MoreString.data)
  return &data_;
}

// -------------------------------------------------------------------

// OneBytes

// optional bytes data = 1;
inline bool OneBytes::has_data() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void OneBytes::set_has_data() {
  _has_bits_[0] |= 0x00000001u;
}
inline void OneBytes::clear_has_data() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void OneBytes::clear_data() {
  data_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
  clear_has_data();
}
inline const ::std::string& OneBytes::data() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.OneBytes.data)
  return data_.Get();
}
inline void OneBytes::set_data(const ::std::string& value) {
  set_has_data();
  data_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set:protobuf_unittest.OneBytes.data)
}
#if LANG_CXX11
inline void OneBytes::set_data(::std::string&& value) {
  set_has_data();
  data_.Set(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_rvalue:protobuf_unittest.OneBytes.data)
}
#endif
inline void OneBytes::set_data(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_data();
  data_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_char:protobuf_unittest.OneBytes.data)
}
inline void OneBytes::set_data(const void* value,
    size_t size) {
  set_has_data();
  data_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_pointer:protobuf_unittest.OneBytes.data)
}
inline ::std::string* OneBytes::mutable_data() {
  set_has_data();
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.OneBytes.data)
  return data_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline ::std::string* OneBytes::release_data() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.OneBytes.data)
  if (!has_data()) {
    return NULL;
  }
  clear_has_data();
  return data_.ReleaseNonDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline void OneBytes::set_allocated_data(::std::string* data) {
  if (data != NULL) {
    set_has_data();
  } else {
    clear_has_data();
  }
  data_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), data,
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.OneBytes.data)
}
inline ::std::string* OneBytes::unsafe_arena_release_data() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.OneBytes.data)
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  clear_has_data();
  return data_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      GetArenaNoVirtual());
}
inline void OneBytes::unsafe_arena_set_allocated_data(
    ::std::string* data) {
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (data != NULL) {
    set_has_data();
  } else {
    clear_has_data();
  }
  data_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      data, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf_unittest.OneBytes.data)
}

// -------------------------------------------------------------------

// MoreBytes

// repeated bytes data = 1;
inline int MoreBytes::data_size() const {
  return data_.size();
}
inline void MoreBytes::clear_data() {
  data_.Clear();
}
inline const ::std::string& MoreBytes::data(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.MoreBytes.data)
  return data_.Get(index);
}
inline ::std::string* MoreBytes::mutable_data(int index) {
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.MoreBytes.data)
  return data_.Mutable(index);
}
inline void MoreBytes::set_data(int index, const ::std::string& value) {
  // @@protoc_insertion_point(field_set:protobuf_unittest.MoreBytes.data)
  data_.Mutable(index)->assign(value);
}
#if LANG_CXX11
inline void MoreBytes::set_data(int index, ::std::string&& value) {
  // @@protoc_insertion_point(field_set:protobuf_unittest.MoreBytes.data)
  data_.Mutable(index)->assign(std::move(value));
}
#endif
inline void MoreBytes::set_data(int index, const char* value) {
  GOOGLE_DCHECK(value != NULL);
  data_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:protobuf_unittest.MoreBytes.data)
}
inline void MoreBytes::set_data(int index, const void* value, size_t size) {
  data_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:protobuf_unittest.MoreBytes.data)
}
inline ::std::string* MoreBytes::add_data() {
  // @@protoc_insertion_point(field_add_mutable:protobuf_unittest.MoreBytes.data)
  return data_.Add();
}
inline void MoreBytes::add_data(const ::std::string& value) {
  data_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest.MoreBytes.data)
}
#if LANG_CXX11
inline void MoreBytes::add_data(::std::string&& value) {
  data_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:protobuf_unittest.MoreBytes.data)
}
#endif
inline void MoreBytes::add_data(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  data_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:protobuf_unittest.MoreBytes.data)
}
inline void MoreBytes::add_data(const void* value, size_t size) {
  data_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:protobuf_unittest.MoreBytes.data)
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
MoreBytes::data() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.MoreBytes.data)
  return data_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
MoreBytes::mutable_data() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.MoreBytes.data)
  return &data_;
}

// -------------------------------------------------------------------

// Int32Message

// optional int32 data = 1;
inline bool Int32Message::has_data() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void Int32Message::set_has_data() {
  _has_bits_[0] |= 0x00000001u;
}
inline void Int32Message::clear_has_data() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void Int32Message::clear_data() {
  data_ = 0;
  clear_has_data();
}
inline ::google::protobuf::int32 Int32Message::data() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.Int32Message.data)
  return data_;
}
inline void Int32Message::set_data(::google::protobuf::int32 value) {
  set_has_data();
  data_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.Int32Message.data)
}

// -------------------------------------------------------------------

// Uint32Message

// optional uint32 data = 1;
inline bool Uint32Message::has_data() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void Uint32Message::set_has_data() {
  _has_bits_[0] |= 0x00000001u;
}
inline void Uint32Message::clear_has_data() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void Uint32Message::clear_data() {
  data_ = 0u;
  clear_has_data();
}
inline ::google::protobuf::uint32 Uint32Message::data() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.Uint32Message.data)
  return data_;
}
inline void Uint32Message::set_data(::google::protobuf::uint32 value) {
  set_has_data();
  data_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.Uint32Message.data)
}

// -------------------------------------------------------------------

// Int64Message

// optional int64 data = 1;
inline bool Int64Message::has_data() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void Int64Message::set_has_data() {
  _has_bits_[0] |= 0x00000001u;
}
inline void Int64Message::clear_has_data() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void Int64Message::clear_data() {
  data_ = GOOGLE_LONGLONG(0);
  clear_has_data();
}
inline ::google::protobuf::int64 Int64Message::data() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.Int64Message.data)
  return data_;
}
inline void Int64Message::set_data(::google::protobuf::int64 value) {
  set_has_data();
  data_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.Int64Message.data)
}

// -------------------------------------------------------------------

// Uint64Message

// optional uint64 data = 1;
inline bool Uint64Message::has_data() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void Uint64Message::set_has_data() {
  _has_bits_[0] |= 0x00000001u;
}
inline void Uint64Message::clear_has_data() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void Uint64Message::clear_data() {
  data_ = GOOGLE_ULONGLONG(0);
  clear_has_data();
}
inline ::google::protobuf::uint64 Uint64Message::data() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.Uint64Message.data)
  return data_;
}
inline void Uint64Message::set_data(::google::protobuf::uint64 value) {
  set_has_data();
  data_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.Uint64Message.data)
}

// -------------------------------------------------------------------

// BoolMessage

// optional bool data = 1;
inline bool BoolMessage::has_data() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void BoolMessage::set_has_data() {
  _has_bits_[0] |= 0x00000001u;
}
inline void BoolMessage::clear_has_data() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void BoolMessage::clear_data() {
  data_ = false;
  clear_has_data();
}
inline bool BoolMessage::data() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.BoolMessage.data)
  return data_;
}
inline void BoolMessage::set_data(bool value) {
  set_has_data();
  data_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.BoolMessage.data)
}

// -------------------------------------------------------------------

// TestOneof_FooGroup

// optional int32 a = 5;
inline bool TestOneof_FooGroup::has_a() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void TestOneof_FooGroup::set_has_a() {
  _has_bits_[0] |= 0x00000002u;
}
inline void TestOneof_FooGroup::clear_has_a() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void TestOneof_FooGroup::clear_a() {
  a_ = 0;
  clear_has_a();
}
inline ::google::protobuf::int32 TestOneof_FooGroup::a() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestOneof.FooGroup.a)
  return a_;
}
inline void TestOneof_FooGroup::set_a(::google::protobuf::int32 value) {
  set_has_a();
  a_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestOneof.FooGroup.a)
}

// optional string b = 6;
inline bool TestOneof_FooGroup::has_b() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TestOneof_FooGroup::set_has_b() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TestOneof_FooGroup::clear_has_b() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TestOneof_FooGroup::clear_b() {
  b_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
  clear_has_b();
}
inline const ::std::string& TestOneof_FooGroup::b() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestOneof.FooGroup.b)
  return b_.Get();
}
inline void TestOneof_FooGroup::set_b(const ::std::string& value) {
  set_has_b();
  b_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestOneof.FooGroup.b)
}
#if LANG_CXX11
inline void TestOneof_FooGroup::set_b(::std::string&& value) {
  set_has_b();
  b_.Set(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_rvalue:protobuf_unittest.TestOneof.FooGroup.b)
}
#endif
inline void TestOneof_FooGroup::set_b(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_b();
  b_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_char:protobuf_unittest.TestOneof.FooGroup.b)
}
inline void TestOneof_FooGroup::set_b(const char* value,
    size_t size) {
  set_has_b();
  b_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_pointer:protobuf_unittest.TestOneof.FooGroup.b)
}
inline ::std::string* TestOneof_FooGroup::mutable_b() {
  set_has_b();
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestOneof.FooGroup.b)
  return b_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline ::std::string* TestOneof_FooGroup::release_b() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestOneof.FooGroup.b)
  if (!has_b()) {
    return NULL;
  }
  clear_has_b();
  return b_.ReleaseNonDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline void TestOneof_FooGroup::set_allocated_b(::std::string* b) {
  if (b != NULL) {
    set_has_b();
  } else {
    clear_has_b();
  }
  b_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), b,
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestOneof.FooGroup.b)
}
inline ::std::string* TestOneof_FooGroup::unsafe_arena_release_b() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestOneof.FooGroup.b)
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  clear_has_b();
  return b_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      GetArenaNoVirtual());
}
inline void TestOneof_FooGroup::unsafe_arena_set_allocated_b(
    ::std::string* b) {
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (b != NULL) {
    set_has_b();
  } else {
    clear_has_b();
  }
  b_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      b, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf_unittest.TestOneof.FooGroup.b)
}

// -------------------------------------------------------------------

// TestOneof

// optional int32 foo_int = 1;
inline bool TestOneof::has_foo_int() const {
  return foo_case() == kFooInt;
}
inline void TestOneof::set_has_foo_int() {
  _oneof_case_[0] = kFooInt;
}
inline void TestOneof::clear_foo_int() {
  if (has_foo_int()) {
    foo_.foo_int_ = 0;
    clear_has_foo();
  }
}
inline ::google::protobuf::int32 TestOneof::foo_int() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestOneof.foo_int)
  if (has_foo_int()) {
    return foo_.foo_int_;
  }
  return 0;
}
inline void TestOneof::set_foo_int(::google::protobuf::int32 value) {
  if (!has_foo_int()) {
    clear_foo();
    set_has_foo_int();
  }
  foo_.foo_int_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestOneof.foo_int)
}

// optional string foo_string = 2;
inline bool TestOneof::has_foo_string() const {
  return foo_case() == kFooString;
}
inline void TestOneof::set_has_foo_string() {
  _oneof_case_[0] = kFooString;
}
inline void TestOneof::clear_foo_string() {
  if (has_foo_string()) {
    foo_.foo_string_.Destroy(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
        GetArenaNoVirtual());
    clear_has_foo();
  }
}
inline const ::std::string& TestOneof::foo_string() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestOneof.foo_string)
  if (has_foo_string()) {
    return foo_.foo_string_.Get();
  }
  return *&::google::protobuf::internal::GetEmptyStringAlreadyInited();
}
inline void TestOneof::set_foo_string(const ::std::string& value) {
  if (!has_foo_string()) {
    clear_foo();
    set_has_foo_string();
    foo_.foo_string_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  foo_.foo_string_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value,
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestOneof.foo_string)
}
#if LANG_CXX11
inline void TestOneof::set_foo_string(::std::string&& value) {
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestOneof.foo_string)
  if (!has_foo_string()) {
    clear_foo();
    set_has_foo_string();
    foo_.foo_string_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  foo_.foo_string_.Set(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_rvalue:protobuf_unittest.TestOneof.foo_string)
}
#endif
inline void TestOneof::set_foo_string(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  if (!has_foo_string()) {
    clear_foo();
    set_has_foo_string();
    foo_.foo_string_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  foo_.foo_string_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(value), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_char:protobuf_unittest.TestOneof.foo_string)
}
inline void TestOneof::set_foo_string(const char* value,
                             size_t size) {
  if (!has_foo_string()) {
    clear_foo();
    set_has_foo_string();
    foo_.foo_string_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  foo_.foo_string_.Set(
      &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size),
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_pointer:protobuf_unittest.TestOneof.foo_string)
}
inline ::std::string* TestOneof::mutable_foo_string() {
  if (!has_foo_string()) {
    clear_foo();
    set_has_foo_string();
    foo_.foo_string_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  return foo_.foo_string_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestOneof.foo_string)
}
inline ::std::string* TestOneof::release_foo_string() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestOneof.foo_string)
  if (has_foo_string()) {
    clear_has_foo();
    return foo_.foo_string_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
        GetArenaNoVirtual());
  } else {
    return NULL;
  }
}
inline void TestOneof::set_allocated_foo_string(::std::string* foo_string) {
  if (!has_foo_string()) {
    foo_.foo_string_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  clear_foo();
  if (foo_string != NULL) {
    set_has_foo_string();
    foo_.foo_string_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), foo_string,
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestOneof.foo_string)
}
inline ::std::string* TestOneof::unsafe_arena_release_foo_string() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestOneof.foo_string)
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (has_foo_string()) {
    clear_has_foo();
    return foo_.foo_string_.UnsafeArenaRelease(
        &::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
  } else {
    return NULL;
  }
}
inline void TestOneof::unsafe_arena_set_allocated_foo_string(::std::string* foo_string) {
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (!has_foo_string()) {
    foo_.foo_string_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  clear_foo();
  if (foo_string) {
    set_has_foo_string();
    foo_.foo_string_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), foo_string, GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf_unittest.TestOneof.foo_string)
}

// optional .protobuf_unittest.TestAllTypes foo_message = 3;
inline bool TestOneof::has_foo_message() const {
  return foo_case() == kFooMessage;
}
inline void TestOneof::set_has_foo_message() {
  _oneof_case_[0] = kFooMessage;
}
inline void TestOneof::clear_foo_message() {
  if (has_foo_message()) {
    if (GetArenaNoVirtual() == NULL) {
      delete foo_.foo_message_;
    }
    clear_has_foo();
  }
}
inline const ::protobuf_unittest::TestAllTypes& TestOneof::_internal_foo_message() const {
  return *foo_.foo_message_;
}
inline ::protobuf_unittest::TestAllTypes* TestOneof::release_foo_message() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestOneof.foo_message)
  if (has_foo_message()) {
    clear_has_foo();
      ::protobuf_unittest::TestAllTypes* temp = foo_.foo_message_;
    if (GetArenaNoVirtual() != NULL) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    foo_.foo_message_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::protobuf_unittest::TestAllTypes& TestOneof::foo_message() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestOneof.foo_message)
  return has_foo_message()
      ? *foo_.foo_message_
      : *reinterpret_cast< ::protobuf_unittest::TestAllTypes*>(&::protobuf_unittest::_TestAllTypes_default_instance_);
}
inline ::protobuf_unittest::TestAllTypes* TestOneof::unsafe_arena_release_foo_message() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestOneof.foo_message)
  if (has_foo_message()) {
    clear_has_foo();
    ::protobuf_unittest::TestAllTypes* temp = foo_.foo_message_;
    foo_.foo_message_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline void TestOneof::unsafe_arena_set_allocated_foo_message(::protobuf_unittest::TestAllTypes* foo_message) {
  clear_foo();
  if (foo_message) {
    set_has_foo_message();
    foo_.foo_message_ = foo_message;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf_unittest.TestOneof.foo_message)
}
inline ::protobuf_unittest::TestAllTypes* TestOneof::mutable_foo_message() {
  if (!has_foo_message()) {
    clear_foo();
    set_has_foo_message();
    foo_.foo_message_ = CreateMaybeMessage< ::protobuf_unittest::TestAllTypes >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestOneof.foo_message)
  return foo_.foo_message_;
}

// optional group FooGroup = 4 { ... };
inline bool TestOneof::has_foogroup() const {
  return foo_case() == kFoogroup;
}
inline void TestOneof::set_has_foogroup() {
  _oneof_case_[0] = kFoogroup;
}
inline void TestOneof::clear_foogroup() {
  if (has_foogroup()) {
    if (GetArenaNoVirtual() == NULL) {
      delete foo_.foogroup_;
    }
    clear_has_foo();
  }
}
inline const ::protobuf_unittest::TestOneof_FooGroup& TestOneof::_internal_foogroup() const {
  return *foo_.foogroup_;
}
inline ::protobuf_unittest::TestOneof_FooGroup* TestOneof::release_foogroup() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestOneof.foogroup)
  if (has_foogroup()) {
    clear_has_foo();
      ::protobuf_unittest::TestOneof_FooGroup* temp = foo_.foogroup_;
    if (GetArenaNoVirtual() != NULL) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    foo_.foogroup_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::protobuf_unittest::TestOneof_FooGroup& TestOneof::foogroup() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestOneof.foogroup)
  return has_foogroup()
      ? *foo_.foogroup_
      : *reinterpret_cast< ::protobuf_unittest::TestOneof_FooGroup*>(&::protobuf_unittest::_TestOneof_FooGroup_default_instance_);
}
inline ::protobuf_unittest::TestOneof_FooGroup* TestOneof::unsafe_arena_release_foogroup() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestOneof.foogroup)
  if (has_foogroup()) {
    clear_has_foo();
    ::protobuf_unittest::TestOneof_FooGroup* temp = foo_.foogroup_;
    foo_.foogroup_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline void TestOneof::unsafe_arena_set_allocated_foogroup(::protobuf_unittest::TestOneof_FooGroup* foogroup) {
  clear_foo();
  if (foogroup) {
    set_has_foogroup();
    foo_.foogroup_ = foogroup;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf_unittest.TestOneof.foogroup)
}
inline ::protobuf_unittest::TestOneof_FooGroup* TestOneof::mutable_foogroup() {
  if (!has_foogroup()) {
    clear_foo();
    set_has_foogroup();
    foo_.foogroup_ = CreateMaybeMessage< ::protobuf_unittest::TestOneof_FooGroup >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestOneof.foogroup)
  return foo_.foogroup_;
}

inline bool TestOneof::has_foo() const {
  return foo_case() != FOO_NOT_SET;
}
inline void TestOneof::clear_has_foo() {
  _oneof_case_[0] = FOO_NOT_SET;
}
inline TestOneof::FooCase TestOneof::foo_case() const {
  return TestOneof::FooCase(_oneof_case_[0]);
}
// -------------------------------------------------------------------

// TestOneofBackwardsCompatible_FooGroup

// optional int32 a = 5;
inline bool TestOneofBackwardsCompatible_FooGroup::has_a() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void TestOneofBackwardsCompatible_FooGroup::set_has_a() {
  _has_bits_[0] |= 0x00000002u;
}
inline void TestOneofBackwardsCompatible_FooGroup::clear_has_a() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void TestOneofBackwardsCompatible_FooGroup::clear_a() {
  a_ = 0;
  clear_has_a();
}
inline ::google::protobuf::int32 TestOneofBackwardsCompatible_FooGroup::a() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestOneofBackwardsCompatible.FooGroup.a)
  return a_;
}
inline void TestOneofBackwardsCompatible_FooGroup::set_a(::google::protobuf::int32 value) {
  set_has_a();
  a_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestOneofBackwardsCompatible.FooGroup.a)
}

// optional string b = 6;
inline bool TestOneofBackwardsCompatible_FooGroup::has_b() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TestOneofBackwardsCompatible_FooGroup::set_has_b() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TestOneofBackwardsCompatible_FooGroup::clear_has_b() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TestOneofBackwardsCompatible_FooGroup::clear_b() {
  b_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
  clear_has_b();
}
inline const ::std::string& TestOneofBackwardsCompatible_FooGroup::b() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestOneofBackwardsCompatible.FooGroup.b)
  return b_.Get();
}
inline void TestOneofBackwardsCompatible_FooGroup::set_b(const ::std::string& value) {
  set_has_b();
  b_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestOneofBackwardsCompatible.FooGroup.b)
}
#if LANG_CXX11
inline void TestOneofBackwardsCompatible_FooGroup::set_b(::std::string&& value) {
  set_has_b();
  b_.Set(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_rvalue:protobuf_unittest.TestOneofBackwardsCompatible.FooGroup.b)
}
#endif
inline void TestOneofBackwardsCompatible_FooGroup::set_b(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_b();
  b_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_char:protobuf_unittest.TestOneofBackwardsCompatible.FooGroup.b)
}
inline void TestOneofBackwardsCompatible_FooGroup::set_b(const char* value,
    size_t size) {
  set_has_b();
  b_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_pointer:protobuf_unittest.TestOneofBackwardsCompatible.FooGroup.b)
}
inline ::std::string* TestOneofBackwardsCompatible_FooGroup::mutable_b() {
  set_has_b();
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestOneofBackwardsCompatible.FooGroup.b)
  return b_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline ::std::string* TestOneofBackwardsCompatible_FooGroup::release_b() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestOneofBackwardsCompatible.FooGroup.b)
  if (!has_b()) {
    return NULL;
  }
  clear_has_b();
  return b_.ReleaseNonDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline void TestOneofBackwardsCompatible_FooGroup::set_allocated_b(::std::string* b) {
  if (b != NULL) {
    set_has_b();
  } else {
    clear_has_b();
  }
  b_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), b,
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestOneofBackwardsCompatible.FooGroup.b)
}
inline ::std::string* TestOneofBackwardsCompatible_FooGroup::unsafe_arena_release_b() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestOneofBackwardsCompatible.FooGroup.b)
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  clear_has_b();
  return b_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      GetArenaNoVirtual());
}
inline void TestOneofBackwardsCompatible_FooGroup::unsafe_arena_set_allocated_b(
    ::std::string* b) {
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (b != NULL) {
    set_has_b();
  } else {
    clear_has_b();
  }
  b_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      b, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf_unittest.TestOneofBackwardsCompatible.FooGroup.b)
}

// -------------------------------------------------------------------

// TestOneofBackwardsCompatible

// optional int32 foo_int = 1;
inline bool TestOneofBackwardsCompatible::has_foo_int() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void TestOneofBackwardsCompatible::set_has_foo_int() {
  _has_bits_[0] |= 0x00000008u;
}
inline void TestOneofBackwardsCompatible::clear_has_foo_int() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void TestOneofBackwardsCompatible::clear_foo_int() {
  foo_int_ = 0;
  clear_has_foo_int();
}
inline ::google::protobuf::int32 TestOneofBackwardsCompatible::foo_int() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestOneofBackwardsCompatible.foo_int)
  return foo_int_;
}
inline void TestOneofBackwardsCompatible::set_foo_int(::google::protobuf::int32 value) {
  set_has_foo_int();
  foo_int_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestOneofBackwardsCompatible.foo_int)
}

// optional string foo_string = 2;
inline bool TestOneofBackwardsCompatible::has_foo_string() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TestOneofBackwardsCompatible::set_has_foo_string() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TestOneofBackwardsCompatible::clear_has_foo_string() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TestOneofBackwardsCompatible::clear_foo_string() {
  foo_string_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
  clear_has_foo_string();
}
inline const ::std::string& TestOneofBackwardsCompatible::foo_string() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestOneofBackwardsCompatible.foo_string)
  return foo_string_.Get();
}
inline void TestOneofBackwardsCompatible::set_foo_string(const ::std::string& value) {
  set_has_foo_string();
  foo_string_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestOneofBackwardsCompatible.foo_string)
}
#if LANG_CXX11
inline void TestOneofBackwardsCompatible::set_foo_string(::std::string&& value) {
  set_has_foo_string();
  foo_string_.Set(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_rvalue:protobuf_unittest.TestOneofBackwardsCompatible.foo_string)
}
#endif
inline void TestOneofBackwardsCompatible::set_foo_string(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_foo_string();
  foo_string_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_char:protobuf_unittest.TestOneofBackwardsCompatible.foo_string)
}
inline void TestOneofBackwardsCompatible::set_foo_string(const char* value,
    size_t size) {
  set_has_foo_string();
  foo_string_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_pointer:protobuf_unittest.TestOneofBackwardsCompatible.foo_string)
}
inline ::std::string* TestOneofBackwardsCompatible::mutable_foo_string() {
  set_has_foo_string();
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestOneofBackwardsCompatible.foo_string)
  return foo_string_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline ::std::string* TestOneofBackwardsCompatible::release_foo_string() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestOneofBackwardsCompatible.foo_string)
  if (!has_foo_string()) {
    return NULL;
  }
  clear_has_foo_string();
  return foo_string_.ReleaseNonDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline void TestOneofBackwardsCompatible::set_allocated_foo_string(::std::string* foo_string) {
  if (foo_string != NULL) {
    set_has_foo_string();
  } else {
    clear_has_foo_string();
  }
  foo_string_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), foo_string,
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestOneofBackwardsCompatible.foo_string)
}
inline ::std::string* TestOneofBackwardsCompatible::unsafe_arena_release_foo_string() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestOneofBackwardsCompatible.foo_string)
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  clear_has_foo_string();
  return foo_string_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      GetArenaNoVirtual());
}
inline void TestOneofBackwardsCompatible::unsafe_arena_set_allocated_foo_string(
    ::std::string* foo_string) {
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (foo_string != NULL) {
    set_has_foo_string();
  } else {
    clear_has_foo_string();
  }
  foo_string_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      foo_string, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf_unittest.TestOneofBackwardsCompatible.foo_string)
}

// optional .protobuf_unittest.TestAllTypes foo_message = 3;
inline bool TestOneofBackwardsCompatible::has_foo_message() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void TestOneofBackwardsCompatible::set_has_foo_message() {
  _has_bits_[0] |= 0x00000002u;
}
inline void TestOneofBackwardsCompatible::clear_has_foo_message() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void TestOneofBackwardsCompatible::clear_foo_message() {
  if (foo_message_ != NULL) foo_message_->Clear();
  clear_has_foo_message();
}
inline const ::protobuf_unittest::TestAllTypes& TestOneofBackwardsCompatible::_internal_foo_message() const {
  return *foo_message_;
}
inline const ::protobuf_unittest::TestAllTypes& TestOneofBackwardsCompatible::foo_message() const {
  const ::protobuf_unittest::TestAllTypes* p = foo_message_;
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestOneofBackwardsCompatible.foo_message)
  return p != NULL ? *p : *reinterpret_cast<const ::protobuf_unittest::TestAllTypes*>(
      &::protobuf_unittest::_TestAllTypes_default_instance_);
}
inline ::protobuf_unittest::TestAllTypes* TestOneofBackwardsCompatible::release_foo_message() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestOneofBackwardsCompatible.foo_message)
  clear_has_foo_message();
  ::protobuf_unittest::TestAllTypes* temp = foo_message_;
  if (GetArenaNoVirtual() != NULL) {
    temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
  }
  foo_message_ = NULL;
  return temp;
}
inline ::protobuf_unittest::TestAllTypes* TestOneofBackwardsCompatible::unsafe_arena_release_foo_message() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestOneofBackwardsCompatible.foo_message)
  clear_has_foo_message();
  ::protobuf_unittest::TestAllTypes* temp = foo_message_;
  foo_message_ = NULL;
  return temp;
}
inline ::protobuf_unittest::TestAllTypes* TestOneofBackwardsCompatible::mutable_foo_message() {
  set_has_foo_message();
  if (foo_message_ == NULL) {
    auto* p = CreateMaybeMessage<::protobuf_unittest::TestAllTypes>(GetArenaNoVirtual());
    foo_message_ = p;
  }
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestOneofBackwardsCompatible.foo_message)
  return foo_message_;
}
inline void TestOneofBackwardsCompatible::set_allocated_foo_message(::protobuf_unittest::TestAllTypes* foo_message) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete foo_message_;
  }
  if (foo_message) {
    ::google::protobuf::Arena* submessage_arena =
      ::google::protobuf::Arena::GetArena(foo_message);
    if (message_arena != submessage_arena) {
      foo_message = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, foo_message, submessage_arena);
    }
    set_has_foo_message();
  } else {
    clear_has_foo_message();
  }
  foo_message_ = foo_message;
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestOneofBackwardsCompatible.foo_message)
}

// optional group FooGroup = 4 { ... };
inline bool TestOneofBackwardsCompatible::has_foogroup() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void TestOneofBackwardsCompatible::set_has_foogroup() {
  _has_bits_[0] |= 0x00000004u;
}
inline void TestOneofBackwardsCompatible::clear_has_foogroup() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void TestOneofBackwardsCompatible::clear_foogroup() {
  if (foogroup_ != NULL) foogroup_->Clear();
  clear_has_foogroup();
}
inline const ::protobuf_unittest::TestOneofBackwardsCompatible_FooGroup& TestOneofBackwardsCompatible::_internal_foogroup() const {
  return *foogroup_;
}
inline const ::protobuf_unittest::TestOneofBackwardsCompatible_FooGroup& TestOneofBackwardsCompatible::foogroup() const {
  const ::protobuf_unittest::TestOneofBackwardsCompatible_FooGroup* p = foogroup_;
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestOneofBackwardsCompatible.foogroup)
  return p != NULL ? *p : *reinterpret_cast<const ::protobuf_unittest::TestOneofBackwardsCompatible_FooGroup*>(
      &::protobuf_unittest::_TestOneofBackwardsCompatible_FooGroup_default_instance_);
}
inline ::protobuf_unittest::TestOneofBackwardsCompatible_FooGroup* TestOneofBackwardsCompatible::release_foogroup() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestOneofBackwardsCompatible.foogroup)
  clear_has_foogroup();
  ::protobuf_unittest::TestOneofBackwardsCompatible_FooGroup* temp = foogroup_;
  if (GetArenaNoVirtual() != NULL) {
    temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
  }
  foogroup_ = NULL;
  return temp;
}
inline ::protobuf_unittest::TestOneofBackwardsCompatible_FooGroup* TestOneofBackwardsCompatible::unsafe_arena_release_foogroup() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestOneofBackwardsCompatible.foogroup)
  clear_has_foogroup();
  ::protobuf_unittest::TestOneofBackwardsCompatible_FooGroup* temp = foogroup_;
  foogroup_ = NULL;
  return temp;
}
inline ::protobuf_unittest::TestOneofBackwardsCompatible_FooGroup* TestOneofBackwardsCompatible::mutable_foogroup() {
  set_has_foogroup();
  if (foogroup_ == NULL) {
    auto* p = CreateMaybeMessage<::protobuf_unittest::TestOneofBackwardsCompatible_FooGroup>(GetArenaNoVirtual());
    foogroup_ = p;
  }
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestOneofBackwardsCompatible.foogroup)
  return foogroup_;
}
inline void TestOneofBackwardsCompatible::set_allocated_foogroup(::protobuf_unittest::TestOneofBackwardsCompatible_FooGroup* foogroup) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete foogroup_;
  }
  if (foogroup) {
    ::google::protobuf::Arena* submessage_arena =
      ::google::protobuf::Arena::GetArena(foogroup);
    if (message_arena != submessage_arena) {
      foogroup = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, foogroup, submessage_arena);
    }
    set_has_foogroup();
  } else {
    clear_has_foogroup();
  }
  foogroup_ = foogroup;
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestOneofBackwardsCompatible.foogroup)
}

// -------------------------------------------------------------------

// TestOneof2_FooGroup

// optional int32 a = 9;
inline bool TestOneof2_FooGroup::has_a() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void TestOneof2_FooGroup::set_has_a() {
  _has_bits_[0] |= 0x00000002u;
}
inline void TestOneof2_FooGroup::clear_has_a() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void TestOneof2_FooGroup::clear_a() {
  a_ = 0;
  clear_has_a();
}
inline ::google::protobuf::int32 TestOneof2_FooGroup::a() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestOneof2.FooGroup.a)
  return a_;
}
inline void TestOneof2_FooGroup::set_a(::google::protobuf::int32 value) {
  set_has_a();
  a_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestOneof2.FooGroup.a)
}

// optional string b = 10;
inline bool TestOneof2_FooGroup::has_b() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TestOneof2_FooGroup::set_has_b() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TestOneof2_FooGroup::clear_has_b() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TestOneof2_FooGroup::clear_b() {
  b_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
  clear_has_b();
}
inline const ::std::string& TestOneof2_FooGroup::b() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestOneof2.FooGroup.b)
  return b_.Get();
}
inline void TestOneof2_FooGroup::set_b(const ::std::string& value) {
  set_has_b();
  b_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestOneof2.FooGroup.b)
}
#if LANG_CXX11
inline void TestOneof2_FooGroup::set_b(::std::string&& value) {
  set_has_b();
  b_.Set(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_rvalue:protobuf_unittest.TestOneof2.FooGroup.b)
}
#endif
inline void TestOneof2_FooGroup::set_b(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_b();
  b_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_char:protobuf_unittest.TestOneof2.FooGroup.b)
}
inline void TestOneof2_FooGroup::set_b(const char* value,
    size_t size) {
  set_has_b();
  b_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_pointer:protobuf_unittest.TestOneof2.FooGroup.b)
}
inline ::std::string* TestOneof2_FooGroup::mutable_b() {
  set_has_b();
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestOneof2.FooGroup.b)
  return b_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline ::std::string* TestOneof2_FooGroup::release_b() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestOneof2.FooGroup.b)
  if (!has_b()) {
    return NULL;
  }
  clear_has_b();
  return b_.ReleaseNonDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline void TestOneof2_FooGroup::set_allocated_b(::std::string* b) {
  if (b != NULL) {
    set_has_b();
  } else {
    clear_has_b();
  }
  b_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), b,
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestOneof2.FooGroup.b)
}
inline ::std::string* TestOneof2_FooGroup::unsafe_arena_release_b() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestOneof2.FooGroup.b)
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  clear_has_b();
  return b_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      GetArenaNoVirtual());
}
inline void TestOneof2_FooGroup::unsafe_arena_set_allocated_b(
    ::std::string* b) {
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (b != NULL) {
    set_has_b();
  } else {
    clear_has_b();
  }
  b_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      b, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf_unittest.TestOneof2.FooGroup.b)
}

// -------------------------------------------------------------------

// TestOneof2_NestedMessage

// optional int64 qux_int = 1;
inline bool TestOneof2_NestedMessage::has_qux_int() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TestOneof2_NestedMessage::set_has_qux_int() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TestOneof2_NestedMessage::clear_has_qux_int() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TestOneof2_NestedMessage::clear_qux_int() {
  qux_int_ = GOOGLE_LONGLONG(0);
  clear_has_qux_int();
}
inline ::google::protobuf::int64 TestOneof2_NestedMessage::qux_int() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestOneof2.NestedMessage.qux_int)
  return qux_int_;
}
inline void TestOneof2_NestedMessage::set_qux_int(::google::protobuf::int64 value) {
  set_has_qux_int();
  qux_int_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestOneof2.NestedMessage.qux_int)
}

// repeated int32 corge_int = 2;
inline int TestOneof2_NestedMessage::corge_int_size() const {
  return corge_int_.size();
}
inline void TestOneof2_NestedMessage::clear_corge_int() {
  corge_int_.Clear();
}
inline ::google::protobuf::int32 TestOneof2_NestedMessage::corge_int(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestOneof2.NestedMessage.corge_int)
  return corge_int_.Get(index);
}
inline void TestOneof2_NestedMessage::set_corge_int(int index, ::google::protobuf::int32 value) {
  corge_int_.Set(index, value);
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestOneof2.NestedMessage.corge_int)
}
inline void TestOneof2_NestedMessage::add_corge_int(::google::protobuf::int32 value) {
  corge_int_.Add(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestOneof2.NestedMessage.corge_int)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
TestOneof2_NestedMessage::corge_int() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestOneof2.NestedMessage.corge_int)
  return corge_int_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
TestOneof2_NestedMessage::mutable_corge_int() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestOneof2.NestedMessage.corge_int)
  return &corge_int_;
}

// -------------------------------------------------------------------

// TestOneof2

// optional int32 foo_int = 1;
inline bool TestOneof2::has_foo_int() const {
  return foo_case() == kFooInt;
}
inline void TestOneof2::set_has_foo_int() {
  _oneof_case_[0] = kFooInt;
}
inline void TestOneof2::clear_foo_int() {
  if (has_foo_int()) {
    foo_.foo_int_ = 0;
    clear_has_foo();
  }
}
inline ::google::protobuf::int32 TestOneof2::foo_int() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestOneof2.foo_int)
  if (has_foo_int()) {
    return foo_.foo_int_;
  }
  return 0;
}
inline void TestOneof2::set_foo_int(::google::protobuf::int32 value) {
  if (!has_foo_int()) {
    clear_foo();
    set_has_foo_int();
  }
  foo_.foo_int_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestOneof2.foo_int)
}

// optional string foo_string = 2;
inline bool TestOneof2::has_foo_string() const {
  return foo_case() == kFooString;
}
inline void TestOneof2::set_has_foo_string() {
  _oneof_case_[0] = kFooString;
}
inline void TestOneof2::clear_foo_string() {
  if (has_foo_string()) {
    foo_.foo_string_.Destroy(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
        GetArenaNoVirtual());
    clear_has_foo();
  }
}
inline const ::std::string& TestOneof2::foo_string() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestOneof2.foo_string)
  if (has_foo_string()) {
    return foo_.foo_string_.Get();
  }
  return *&::google::protobuf::internal::GetEmptyStringAlreadyInited();
}
inline void TestOneof2::set_foo_string(const ::std::string& value) {
  if (!has_foo_string()) {
    clear_foo();
    set_has_foo_string();
    foo_.foo_string_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  foo_.foo_string_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value,
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestOneof2.foo_string)
}
#if LANG_CXX11
inline void TestOneof2::set_foo_string(::std::string&& value) {
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestOneof2.foo_string)
  if (!has_foo_string()) {
    clear_foo();
    set_has_foo_string();
    foo_.foo_string_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  foo_.foo_string_.Set(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_rvalue:protobuf_unittest.TestOneof2.foo_string)
}
#endif
inline void TestOneof2::set_foo_string(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  if (!has_foo_string()) {
    clear_foo();
    set_has_foo_string();
    foo_.foo_string_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  foo_.foo_string_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(value), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_char:protobuf_unittest.TestOneof2.foo_string)
}
inline void TestOneof2::set_foo_string(const char* value,
                             size_t size) {
  if (!has_foo_string()) {
    clear_foo();
    set_has_foo_string();
    foo_.foo_string_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  foo_.foo_string_.Set(
      &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size),
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_pointer:protobuf_unittest.TestOneof2.foo_string)
}
inline ::std::string* TestOneof2::mutable_foo_string() {
  if (!has_foo_string()) {
    clear_foo();
    set_has_foo_string();
    foo_.foo_string_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  return foo_.foo_string_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestOneof2.foo_string)
}
inline ::std::string* TestOneof2::release_foo_string() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestOneof2.foo_string)
  if (has_foo_string()) {
    clear_has_foo();
    return foo_.foo_string_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
        GetArenaNoVirtual());
  } else {
    return NULL;
  }
}
inline void TestOneof2::set_allocated_foo_string(::std::string* foo_string) {
  if (!has_foo_string()) {
    foo_.foo_string_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  clear_foo();
  if (foo_string != NULL) {
    set_has_foo_string();
    foo_.foo_string_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), foo_string,
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestOneof2.foo_string)
}
inline ::std::string* TestOneof2::unsafe_arena_release_foo_string() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestOneof2.foo_string)
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (has_foo_string()) {
    clear_has_foo();
    return foo_.foo_string_.UnsafeArenaRelease(
        &::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
  } else {
    return NULL;
  }
}
inline void TestOneof2::unsafe_arena_set_allocated_foo_string(::std::string* foo_string) {
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (!has_foo_string()) {
    foo_.foo_string_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  clear_foo();
  if (foo_string) {
    set_has_foo_string();
    foo_.foo_string_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), foo_string, GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf_unittest.TestOneof2.foo_string)
}

// optional string foo_cord = 3 [ctype = CORD];
inline bool TestOneof2::has_foo_cord() const {
  return foo_case() == kFooCord;
}
inline void TestOneof2::set_has_foo_cord() {
  _oneof_case_[0] = kFooCord;
}
inline void TestOneof2::clear_foo_cord() {
  if (has_foo_cord()) {
    foo_.foo_cord_.Destroy(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
        GetArenaNoVirtual());
    clear_has_foo();
  }
}
inline const ::std::string& TestOneof2::foo_cord() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestOneof2.foo_cord)
  if (has_foo_cord()) {
    return foo_.foo_cord_.Get();
  }
  return *&::google::protobuf::internal::GetEmptyStringAlreadyInited();
}
inline void TestOneof2::set_foo_cord(const ::std::string& value) {
  if (!has_foo_cord()) {
    clear_foo();
    set_has_foo_cord();
    foo_.foo_cord_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  foo_.foo_cord_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value,
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestOneof2.foo_cord)
}
#if LANG_CXX11
inline void TestOneof2::set_foo_cord(::std::string&& value) {
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestOneof2.foo_cord)
  if (!has_foo_cord()) {
    clear_foo();
    set_has_foo_cord();
    foo_.foo_cord_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  foo_.foo_cord_.Set(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_rvalue:protobuf_unittest.TestOneof2.foo_cord)
}
#endif
inline void TestOneof2::set_foo_cord(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  if (!has_foo_cord()) {
    clear_foo();
    set_has_foo_cord();
    foo_.foo_cord_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  foo_.foo_cord_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(value), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_char:protobuf_unittest.TestOneof2.foo_cord)
}
inline void TestOneof2::set_foo_cord(const char* value,
                             size_t size) {
  if (!has_foo_cord()) {
    clear_foo();
    set_has_foo_cord();
    foo_.foo_cord_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  foo_.foo_cord_.Set(
      &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size),
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_pointer:protobuf_unittest.TestOneof2.foo_cord)
}
inline ::std::string* TestOneof2::mutable_foo_cord() {
  if (!has_foo_cord()) {
    clear_foo();
    set_has_foo_cord();
    foo_.foo_cord_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  return foo_.foo_cord_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestOneof2.foo_cord)
}
inline ::std::string* TestOneof2::release_foo_cord() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestOneof2.foo_cord)
  if (has_foo_cord()) {
    clear_has_foo();
    return foo_.foo_cord_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
        GetArenaNoVirtual());
  } else {
    return NULL;
  }
}
inline void TestOneof2::set_allocated_foo_cord(::std::string* foo_cord) {
  if (!has_foo_cord()) {
    foo_.foo_cord_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  clear_foo();
  if (foo_cord != NULL) {
    set_has_foo_cord();
    foo_.foo_cord_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), foo_cord,
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestOneof2.foo_cord)
}
inline ::std::string* TestOneof2::unsafe_arena_release_foo_cord() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestOneof2.foo_cord)
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (has_foo_cord()) {
    clear_has_foo();
    return foo_.foo_cord_.UnsafeArenaRelease(
        &::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
  } else {
    return NULL;
  }
}
inline void TestOneof2::unsafe_arena_set_allocated_foo_cord(::std::string* foo_cord) {
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (!has_foo_cord()) {
    foo_.foo_cord_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  clear_foo();
  if (foo_cord) {
    set_has_foo_cord();
    foo_.foo_cord_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), foo_cord, GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf_unittest.TestOneof2.foo_cord)
}

// optional string foo_string_piece = 4 [ctype = STRING_PIECE];
inline bool TestOneof2::has_foo_string_piece() const {
  return foo_case() == kFooStringPiece;
}
inline void TestOneof2::set_has_foo_string_piece() {
  _oneof_case_[0] = kFooStringPiece;
}
inline void TestOneof2::clear_foo_string_piece() {
  if (has_foo_string_piece()) {
    foo_.foo_string_piece_.Destroy(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
        GetArenaNoVirtual());
    clear_has_foo();
  }
}
inline const ::std::string& TestOneof2::foo_string_piece() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestOneof2.foo_string_piece)
  if (has_foo_string_piece()) {
    return foo_.foo_string_piece_.Get();
  }
  return *&::google::protobuf::internal::GetEmptyStringAlreadyInited();
}
inline void TestOneof2::set_foo_string_piece(const ::std::string& value) {
  if (!has_foo_string_piece()) {
    clear_foo();
    set_has_foo_string_piece();
    foo_.foo_string_piece_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  foo_.foo_string_piece_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value,
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestOneof2.foo_string_piece)
}
#if LANG_CXX11
inline void TestOneof2::set_foo_string_piece(::std::string&& value) {
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestOneof2.foo_string_piece)
  if (!has_foo_string_piece()) {
    clear_foo();
    set_has_foo_string_piece();
    foo_.foo_string_piece_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  foo_.foo_string_piece_.Set(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_rvalue:protobuf_unittest.TestOneof2.foo_string_piece)
}
#endif
inline void TestOneof2::set_foo_string_piece(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  if (!has_foo_string_piece()) {
    clear_foo();
    set_has_foo_string_piece();
    foo_.foo_string_piece_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  foo_.foo_string_piece_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(value), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_char:protobuf_unittest.TestOneof2.foo_string_piece)
}
inline void TestOneof2::set_foo_string_piece(const char* value,
                             size_t size) {
  if (!has_foo_string_piece()) {
    clear_foo();
    set_has_foo_string_piece();
    foo_.foo_string_piece_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  foo_.foo_string_piece_.Set(
      &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size),
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_pointer:protobuf_unittest.TestOneof2.foo_string_piece)
}
inline ::std::string* TestOneof2::mutable_foo_string_piece() {
  if (!has_foo_string_piece()) {
    clear_foo();
    set_has_foo_string_piece();
    foo_.foo_string_piece_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  return foo_.foo_string_piece_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestOneof2.foo_string_piece)
}
inline ::std::string* TestOneof2::release_foo_string_piece() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestOneof2.foo_string_piece)
  if (has_foo_string_piece()) {
    clear_has_foo();
    return foo_.foo_string_piece_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
        GetArenaNoVirtual());
  } else {
    return NULL;
  }
}
inline void TestOneof2::set_allocated_foo_string_piece(::std::string* foo_string_piece) {
  if (!has_foo_string_piece()) {
    foo_.foo_string_piece_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  clear_foo();
  if (foo_string_piece != NULL) {
    set_has_foo_string_piece();
    foo_.foo_string_piece_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), foo_string_piece,
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestOneof2.foo_string_piece)
}
inline ::std::string* TestOneof2::unsafe_arena_release_foo_string_piece() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestOneof2.foo_string_piece)
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (has_foo_string_piece()) {
    clear_has_foo();
    return foo_.foo_string_piece_.UnsafeArenaRelease(
        &::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
  } else {
    return NULL;
  }
}
inline void TestOneof2::unsafe_arena_set_allocated_foo_string_piece(::std::string* foo_string_piece) {
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (!has_foo_string_piece()) {
    foo_.foo_string_piece_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  clear_foo();
  if (foo_string_piece) {
    set_has_foo_string_piece();
    foo_.foo_string_piece_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), foo_string_piece, GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf_unittest.TestOneof2.foo_string_piece)
}

// optional bytes foo_bytes = 5;
inline bool TestOneof2::has_foo_bytes() const {
  return foo_case() == kFooBytes;
}
inline void TestOneof2::set_has_foo_bytes() {
  _oneof_case_[0] = kFooBytes;
}
inline void TestOneof2::clear_foo_bytes() {
  if (has_foo_bytes()) {
    foo_.foo_bytes_.Destroy(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
        GetArenaNoVirtual());
    clear_has_foo();
  }
}
inline const ::std::string& TestOneof2::foo_bytes() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestOneof2.foo_bytes)
  if (has_foo_bytes()) {
    return foo_.foo_bytes_.Get();
  }
  return *&::google::protobuf::internal::GetEmptyStringAlreadyInited();
}
inline void TestOneof2::set_foo_bytes(const ::std::string& value) {
  if (!has_foo_bytes()) {
    clear_foo();
    set_has_foo_bytes();
    foo_.foo_bytes_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  foo_.foo_bytes_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value,
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestOneof2.foo_bytes)
}
#if LANG_CXX11
inline void TestOneof2::set_foo_bytes(::std::string&& value) {
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestOneof2.foo_bytes)
  if (!has_foo_bytes()) {
    clear_foo();
    set_has_foo_bytes();
    foo_.foo_bytes_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  foo_.foo_bytes_.Set(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_rvalue:protobuf_unittest.TestOneof2.foo_bytes)
}
#endif
inline void TestOneof2::set_foo_bytes(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  if (!has_foo_bytes()) {
    clear_foo();
    set_has_foo_bytes();
    foo_.foo_bytes_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  foo_.foo_bytes_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(value), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_char:protobuf_unittest.TestOneof2.foo_bytes)
}
inline void TestOneof2::set_foo_bytes(const void* value,
                             size_t size) {
  if (!has_foo_bytes()) {
    clear_foo();
    set_has_foo_bytes();
    foo_.foo_bytes_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  foo_.foo_bytes_.Set(
      &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size),
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_pointer:protobuf_unittest.TestOneof2.foo_bytes)
}
inline ::std::string* TestOneof2::mutable_foo_bytes() {
  if (!has_foo_bytes()) {
    clear_foo();
    set_has_foo_bytes();
    foo_.foo_bytes_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  return foo_.foo_bytes_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestOneof2.foo_bytes)
}
inline ::std::string* TestOneof2::release_foo_bytes() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestOneof2.foo_bytes)
  if (has_foo_bytes()) {
    clear_has_foo();
    return foo_.foo_bytes_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
        GetArenaNoVirtual());
  } else {
    return NULL;
  }
}
inline void TestOneof2::set_allocated_foo_bytes(::std::string* foo_bytes) {
  if (!has_foo_bytes()) {
    foo_.foo_bytes_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  clear_foo();
  if (foo_bytes != NULL) {
    set_has_foo_bytes();
    foo_.foo_bytes_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), foo_bytes,
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestOneof2.foo_bytes)
}
inline ::std::string* TestOneof2::unsafe_arena_release_foo_bytes() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestOneof2.foo_bytes)
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (has_foo_bytes()) {
    clear_has_foo();
    return foo_.foo_bytes_.UnsafeArenaRelease(
        &::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
  } else {
    return NULL;
  }
}
inline void TestOneof2::unsafe_arena_set_allocated_foo_bytes(::std::string* foo_bytes) {
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (!has_foo_bytes()) {
    foo_.foo_bytes_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  clear_foo();
  if (foo_bytes) {
    set_has_foo_bytes();
    foo_.foo_bytes_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), foo_bytes, GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf_unittest.TestOneof2.foo_bytes)
}

// optional .protobuf_unittest.TestOneof2.NestedEnum foo_enum = 6;
inline bool TestOneof2::has_foo_enum() const {
  return foo_case() == kFooEnum;
}
inline void TestOneof2::set_has_foo_enum() {
  _oneof_case_[0] = kFooEnum;
}
inline void TestOneof2::clear_foo_enum() {
  if (has_foo_enum()) {
    foo_.foo_enum_ = 1;
    clear_has_foo();
  }
}
inline ::protobuf_unittest::TestOneof2_NestedEnum TestOneof2::foo_enum() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestOneof2.foo_enum)
  if (has_foo_enum()) {
    return static_cast< ::protobuf_unittest::TestOneof2_NestedEnum >(foo_.foo_enum_);
  }
  return static_cast< ::protobuf_unittest::TestOneof2_NestedEnum >(1);
}
inline void TestOneof2::set_foo_enum(::protobuf_unittest::TestOneof2_NestedEnum value) {
  assert(::protobuf_unittest::TestOneof2_NestedEnum_IsValid(value));
  if (!has_foo_enum()) {
    clear_foo();
    set_has_foo_enum();
  }
  foo_.foo_enum_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestOneof2.foo_enum)
}

// optional .protobuf_unittest.TestOneof2.NestedMessage foo_message = 7;
inline bool TestOneof2::has_foo_message() const {
  return foo_case() == kFooMessage;
}
inline void TestOneof2::set_has_foo_message() {
  _oneof_case_[0] = kFooMessage;
}
inline void TestOneof2::clear_foo_message() {
  if (has_foo_message()) {
    if (GetArenaNoVirtual() == NULL) {
      delete foo_.foo_message_;
    }
    clear_has_foo();
  }
}
inline const ::protobuf_unittest::TestOneof2_NestedMessage& TestOneof2::_internal_foo_message() const {
  return *foo_.foo_message_;
}
inline ::protobuf_unittest::TestOneof2_NestedMessage* TestOneof2::release_foo_message() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestOneof2.foo_message)
  if (has_foo_message()) {
    clear_has_foo();
      ::protobuf_unittest::TestOneof2_NestedMessage* temp = foo_.foo_message_;
    if (GetArenaNoVirtual() != NULL) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    foo_.foo_message_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::protobuf_unittest::TestOneof2_NestedMessage& TestOneof2::foo_message() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestOneof2.foo_message)
  return has_foo_message()
      ? *foo_.foo_message_
      : *reinterpret_cast< ::protobuf_unittest::TestOneof2_NestedMessage*>(&::protobuf_unittest::_TestOneof2_NestedMessage_default_instance_);
}
inline ::protobuf_unittest::TestOneof2_NestedMessage* TestOneof2::unsafe_arena_release_foo_message() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestOneof2.foo_message)
  if (has_foo_message()) {
    clear_has_foo();
    ::protobuf_unittest::TestOneof2_NestedMessage* temp = foo_.foo_message_;
    foo_.foo_message_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline void TestOneof2::unsafe_arena_set_allocated_foo_message(::protobuf_unittest::TestOneof2_NestedMessage* foo_message) {
  clear_foo();
  if (foo_message) {
    set_has_foo_message();
    foo_.foo_message_ = foo_message;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf_unittest.TestOneof2.foo_message)
}
inline ::protobuf_unittest::TestOneof2_NestedMessage* TestOneof2::mutable_foo_message() {
  if (!has_foo_message()) {
    clear_foo();
    set_has_foo_message();
    foo_.foo_message_ = CreateMaybeMessage< ::protobuf_unittest::TestOneof2_NestedMessage >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestOneof2.foo_message)
  return foo_.foo_message_;
}

// optional group FooGroup = 8 { ... };
inline bool TestOneof2::has_foogroup() const {
  return foo_case() == kFoogroup;
}
inline void TestOneof2::set_has_foogroup() {
  _oneof_case_[0] = kFoogroup;
}
inline void TestOneof2::clear_foogroup() {
  if (has_foogroup()) {
    if (GetArenaNoVirtual() == NULL) {
      delete foo_.foogroup_;
    }
    clear_has_foo();
  }
}
inline const ::protobuf_unittest::TestOneof2_FooGroup& TestOneof2::_internal_foogroup() const {
  return *foo_.foogroup_;
}
inline ::protobuf_unittest::TestOneof2_FooGroup* TestOneof2::release_foogroup() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestOneof2.foogroup)
  if (has_foogroup()) {
    clear_has_foo();
      ::protobuf_unittest::TestOneof2_FooGroup* temp = foo_.foogroup_;
    if (GetArenaNoVirtual() != NULL) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    foo_.foogroup_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::protobuf_unittest::TestOneof2_FooGroup& TestOneof2::foogroup() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestOneof2.foogroup)
  return has_foogroup()
      ? *foo_.foogroup_
      : *reinterpret_cast< ::protobuf_unittest::TestOneof2_FooGroup*>(&::protobuf_unittest::_TestOneof2_FooGroup_default_instance_);
}
inline ::protobuf_unittest::TestOneof2_FooGroup* TestOneof2::unsafe_arena_release_foogroup() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestOneof2.foogroup)
  if (has_foogroup()) {
    clear_has_foo();
    ::protobuf_unittest::TestOneof2_FooGroup* temp = foo_.foogroup_;
    foo_.foogroup_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline void TestOneof2::unsafe_arena_set_allocated_foogroup(::protobuf_unittest::TestOneof2_FooGroup* foogroup) {
  clear_foo();
  if (foogroup) {
    set_has_foogroup();
    foo_.foogroup_ = foogroup;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf_unittest.TestOneof2.foogroup)
}
inline ::protobuf_unittest::TestOneof2_FooGroup* TestOneof2::mutable_foogroup() {
  if (!has_foogroup()) {
    clear_foo();
    set_has_foogroup();
    foo_.foogroup_ = CreateMaybeMessage< ::protobuf_unittest::TestOneof2_FooGroup >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestOneof2.foogroup)
  return foo_.foogroup_;
}

// optional .protobuf_unittest.TestOneof2.NestedMessage foo_lazy_message = 11 [lazy = true];
inline bool TestOneof2::has_foo_lazy_message() const {
  return foo_case() == kFooLazyMessage;
}
inline void TestOneof2::set_has_foo_lazy_message() {
  _oneof_case_[0] = kFooLazyMessage;
}
inline void TestOneof2::clear_foo_lazy_message() {
  if (has_foo_lazy_message()) {
    if (GetArenaNoVirtual() == NULL) {
      delete foo_.foo_lazy_message_;
    }
    clear_has_foo();
  }
}
inline const ::protobuf_unittest::TestOneof2_NestedMessage& TestOneof2::_internal_foo_lazy_message() const {
  return *foo_.foo_lazy_message_;
}
inline ::protobuf_unittest::TestOneof2_NestedMessage* TestOneof2::release_foo_lazy_message() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestOneof2.foo_lazy_message)
  if (has_foo_lazy_message()) {
    clear_has_foo();
      ::protobuf_unittest::TestOneof2_NestedMessage* temp = foo_.foo_lazy_message_;
    if (GetArenaNoVirtual() != NULL) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    foo_.foo_lazy_message_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::protobuf_unittest::TestOneof2_NestedMessage& TestOneof2::foo_lazy_message() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestOneof2.foo_lazy_message)
  return has_foo_lazy_message()
      ? *foo_.foo_lazy_message_
      : *reinterpret_cast< ::protobuf_unittest::TestOneof2_NestedMessage*>(&::protobuf_unittest::_TestOneof2_NestedMessage_default_instance_);
}
inline ::protobuf_unittest::TestOneof2_NestedMessage* TestOneof2::unsafe_arena_release_foo_lazy_message() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestOneof2.foo_lazy_message)
  if (has_foo_lazy_message()) {
    clear_has_foo();
    ::protobuf_unittest::TestOneof2_NestedMessage* temp = foo_.foo_lazy_message_;
    foo_.foo_lazy_message_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline void TestOneof2::unsafe_arena_set_allocated_foo_lazy_message(::protobuf_unittest::TestOneof2_NestedMessage* foo_lazy_message) {
  clear_foo();
  if (foo_lazy_message) {
    set_has_foo_lazy_message();
    foo_.foo_lazy_message_ = foo_lazy_message;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf_unittest.TestOneof2.foo_lazy_message)
}
inline ::protobuf_unittest::TestOneof2_NestedMessage* TestOneof2::mutable_foo_lazy_message() {
  if (!has_foo_lazy_message()) {
    clear_foo();
    set_has_foo_lazy_message();
    foo_.foo_lazy_message_ = CreateMaybeMessage< ::protobuf_unittest::TestOneof2_NestedMessage >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestOneof2.foo_lazy_message)
  return foo_.foo_lazy_message_;
}

// optional int32 bar_int = 12 [default = 5];
inline bool TestOneof2::has_bar_int() const {
  return bar_case() == kBarInt;
}
inline void TestOneof2::set_has_bar_int() {
  _oneof_case_[1] = kBarInt;
}
inline void TestOneof2::clear_bar_int() {
  if (has_bar_int()) {
    bar_.bar_int_ = 5;
    clear_has_bar();
  }
}
inline ::google::protobuf::int32 TestOneof2::bar_int() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestOneof2.bar_int)
  if (has_bar_int()) {
    return bar_.bar_int_;
  }
  return 5;
}
inline void TestOneof2::set_bar_int(::google::protobuf::int32 value) {
  if (!has_bar_int()) {
    clear_bar();
    set_has_bar_int();
  }
  bar_.bar_int_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestOneof2.bar_int)
}

// optional string bar_string = 13 [default = "STRING"];
inline bool TestOneof2::has_bar_string() const {
  return bar_case() == kBarString;
}
inline void TestOneof2::set_has_bar_string() {
  _oneof_case_[1] = kBarString;
}
inline void TestOneof2::clear_bar_string() {
  if (has_bar_string()) {
    bar_.bar_string_.Destroy(&::protobuf_unittest::TestOneof2::_i_give_permission_to_break_this_code_default_bar_string_.get(),
        GetArenaNoVirtual());
    clear_has_bar();
  }
}
inline const ::std::string& TestOneof2::bar_string() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestOneof2.bar_string)
  if (has_bar_string()) {
    return bar_.bar_string_.Get();
  }
  return *&::protobuf_unittest::TestOneof2::_i_give_permission_to_break_this_code_default_bar_string_.get();
}
inline void TestOneof2::set_bar_string(const ::std::string& value) {
  if (!has_bar_string()) {
    clear_bar();
    set_has_bar_string();
    bar_.bar_string_.UnsafeSetDefault(&::protobuf_unittest::TestOneof2::_i_give_permission_to_break_this_code_default_bar_string_.get());
  }
  bar_.bar_string_.Set(&::protobuf_unittest::TestOneof2::_i_give_permission_to_break_this_code_default_bar_string_.get(), value,
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestOneof2.bar_string)
}
#if LANG_CXX11
inline void TestOneof2::set_bar_string(::std::string&& value) {
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestOneof2.bar_string)
  if (!has_bar_string()) {
    clear_bar();
    set_has_bar_string();
    bar_.bar_string_.UnsafeSetDefault(&::protobuf_unittest::TestOneof2::_i_give_permission_to_break_this_code_default_bar_string_.get());
  }
  bar_.bar_string_.Set(
    &::protobuf_unittest::TestOneof2::_i_give_permission_to_break_this_code_default_bar_string_.get(), ::std::move(value), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_rvalue:protobuf_unittest.TestOneof2.bar_string)
}
#endif
inline void TestOneof2::set_bar_string(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  if (!has_bar_string()) {
    clear_bar();
    set_has_bar_string();
    bar_.bar_string_.UnsafeSetDefault(&::protobuf_unittest::TestOneof2::_i_give_permission_to_break_this_code_default_bar_string_.get());
  }
  bar_.bar_string_.Set(&::protobuf_unittest::TestOneof2::_i_give_permission_to_break_this_code_default_bar_string_.get(),
      ::std::string(value), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_char:protobuf_unittest.TestOneof2.bar_string)
}
inline void TestOneof2::set_bar_string(const char* value,
                             size_t size) {
  if (!has_bar_string()) {
    clear_bar();
    set_has_bar_string();
    bar_.bar_string_.UnsafeSetDefault(&::protobuf_unittest::TestOneof2::_i_give_permission_to_break_this_code_default_bar_string_.get());
  }
  bar_.bar_string_.Set(
      &::protobuf_unittest::TestOneof2::_i_give_permission_to_break_this_code_default_bar_string_.get(), ::std::string(
      reinterpret_cast<const char*>(value), size),
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_pointer:protobuf_unittest.TestOneof2.bar_string)
}
inline ::std::string* TestOneof2::mutable_bar_string() {
  if (!has_bar_string()) {
    clear_bar();
    set_has_bar_string();
    bar_.bar_string_.UnsafeSetDefault(&::protobuf_unittest::TestOneof2::_i_give_permission_to_break_this_code_default_bar_string_.get());
  }
  return bar_.bar_string_.Mutable(&::protobuf_unittest::TestOneof2::_i_give_permission_to_break_this_code_default_bar_string_.get(),
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestOneof2.bar_string)
}
inline ::std::string* TestOneof2::release_bar_string() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestOneof2.bar_string)
  if (has_bar_string()) {
    clear_has_bar();
    return bar_.bar_string_.Release(&::protobuf_unittest::TestOneof2::_i_give_permission_to_break_this_code_default_bar_string_.get(),
        GetArenaNoVirtual());
  } else {
    return NULL;
  }
}
inline void TestOneof2::set_allocated_bar_string(::std::string* bar_string) {
  if (!has_bar_string()) {
    bar_.bar_string_.UnsafeSetDefault(&::protobuf_unittest::TestOneof2::_i_give_permission_to_break_this_code_default_bar_string_.get());
  }
  clear_bar();
  if (bar_string != NULL) {
    set_has_bar_string();
    bar_.bar_string_.SetAllocated(&::protobuf_unittest::TestOneof2::_i_give_permission_to_break_this_code_default_bar_string_.get(), bar_string,
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestOneof2.bar_string)
}
inline ::std::string* TestOneof2::unsafe_arena_release_bar_string() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestOneof2.bar_string)
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (has_bar_string()) {
    clear_has_bar();
    return bar_.bar_string_.UnsafeArenaRelease(
        &::protobuf_unittest::TestOneof2::_i_give_permission_to_break_this_code_default_bar_string_.get(), GetArenaNoVirtual());
  } else {
    return NULL;
  }
}
inline void TestOneof2::unsafe_arena_set_allocated_bar_string(::std::string* bar_string) {
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (!has_bar_string()) {
    bar_.bar_string_.UnsafeSetDefault(&::protobuf_unittest::TestOneof2::_i_give_permission_to_break_this_code_default_bar_string_.get());
  }
  clear_bar();
  if (bar_string) {
    set_has_bar_string();
    bar_.bar_string_.UnsafeArenaSetAllocated(&::protobuf_unittest::TestOneof2::_i_give_permission_to_break_this_code_default_bar_string_.get(), bar_string, GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf_unittest.TestOneof2.bar_string)
}

// optional string bar_cord = 14 [default = "CORD", ctype = CORD];
inline bool TestOneof2::has_bar_cord() const {
  return bar_case() == kBarCord;
}
inline void TestOneof2::set_has_bar_cord() {
  _oneof_case_[1] = kBarCord;
}
inline void TestOneof2::clear_bar_cord() {
  if (has_bar_cord()) {
    bar_.bar_cord_.Destroy(&::protobuf_unittest::TestOneof2::_i_give_permission_to_break_this_code_default_bar_cord_.get(),
        GetArenaNoVirtual());
    clear_has_bar();
  }
}
inline const ::std::string& TestOneof2::bar_cord() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestOneof2.bar_cord)
  if (has_bar_cord()) {
    return bar_.bar_cord_.Get();
  }
  return *&::protobuf_unittest::TestOneof2::_i_give_permission_to_break_this_code_default_bar_cord_.get();
}
inline void TestOneof2::set_bar_cord(const ::std::string& value) {
  if (!has_bar_cord()) {
    clear_bar();
    set_has_bar_cord();
    bar_.bar_cord_.UnsafeSetDefault(&::protobuf_unittest::TestOneof2::_i_give_permission_to_break_this_code_default_bar_cord_.get());
  }
  bar_.bar_cord_.Set(&::protobuf_unittest::TestOneof2::_i_give_permission_to_break_this_code_default_bar_cord_.get(), value,
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestOneof2.bar_cord)
}
#if LANG_CXX11
inline void TestOneof2::set_bar_cord(::std::string&& value) {
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestOneof2.bar_cord)
  if (!has_bar_cord()) {
    clear_bar();
    set_has_bar_cord();
    bar_.bar_cord_.UnsafeSetDefault(&::protobuf_unittest::TestOneof2::_i_give_permission_to_break_this_code_default_bar_cord_.get());
  }
  bar_.bar_cord_.Set(
    &::protobuf_unittest::TestOneof2::_i_give_permission_to_break_this_code_default_bar_cord_.get(), ::std::move(value), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_rvalue:protobuf_unittest.TestOneof2.bar_cord)
}
#endif
inline void TestOneof2::set_bar_cord(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  if (!has_bar_cord()) {
    clear_bar();
    set_has_bar_cord();
    bar_.bar_cord_.UnsafeSetDefault(&::protobuf_unittest::TestOneof2::_i_give_permission_to_break_this_code_default_bar_cord_.get());
  }
  bar_.bar_cord_.Set(&::protobuf_unittest::TestOneof2::_i_give_permission_to_break_this_code_default_bar_cord_.get(),
      ::std::string(value), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_char:protobuf_unittest.TestOneof2.bar_cord)
}
inline void TestOneof2::set_bar_cord(const char* value,
                             size_t size) {
  if (!has_bar_cord()) {
    clear_bar();
    set_has_bar_cord();
    bar_.bar_cord_.UnsafeSetDefault(&::protobuf_unittest::TestOneof2::_i_give_permission_to_break_this_code_default_bar_cord_.get());
  }
  bar_.bar_cord_.Set(
      &::protobuf_unittest::TestOneof2::_i_give_permission_to_break_this_code_default_bar_cord_.get(), ::std::string(
      reinterpret_cast<const char*>(value), size),
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_pointer:protobuf_unittest.TestOneof2.bar_cord)
}
inline ::std::string* TestOneof2::mutable_bar_cord() {
  if (!has_bar_cord()) {
    clear_bar();
    set_has_bar_cord();
    bar_.bar_cord_.UnsafeSetDefault(&::protobuf_unittest::TestOneof2::_i_give_permission_to_break_this_code_default_bar_cord_.get());
  }
  return bar_.bar_cord_.Mutable(&::protobuf_unittest::TestOneof2::_i_give_permission_to_break_this_code_default_bar_cord_.get(),
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestOneof2.bar_cord)
}
inline ::std::string* TestOneof2::release_bar_cord() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestOneof2.bar_cord)
  if (has_bar_cord()) {
    clear_has_bar();
    return bar_.bar_cord_.Release(&::protobuf_unittest::TestOneof2::_i_give_permission_to_break_this_code_default_bar_cord_.get(),
        GetArenaNoVirtual());
  } else {
    return NULL;
  }
}
inline void TestOneof2::set_allocated_bar_cord(::std::string* bar_cord) {
  if (!has_bar_cord()) {
    bar_.bar_cord_.UnsafeSetDefault(&::protobuf_unittest::TestOneof2::_i_give_permission_to_break_this_code_default_bar_cord_.get());
  }
  clear_bar();
  if (bar_cord != NULL) {
    set_has_bar_cord();
    bar_.bar_cord_.SetAllocated(&::protobuf_unittest::TestOneof2::_i_give_permission_to_break_this_code_default_bar_cord_.get(), bar_cord,
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestOneof2.bar_cord)
}
inline ::std::string* TestOneof2::unsafe_arena_release_bar_cord() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestOneof2.bar_cord)
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (has_bar_cord()) {
    clear_has_bar();
    return bar_.bar_cord_.UnsafeArenaRelease(
        &::protobuf_unittest::TestOneof2::_i_give_permission_to_break_this_code_default_bar_cord_.get(), GetArenaNoVirtual());
  } else {
    return NULL;
  }
}
inline void TestOneof2::unsafe_arena_set_allocated_bar_cord(::std::string* bar_cord) {
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (!has_bar_cord()) {
    bar_.bar_cord_.UnsafeSetDefault(&::protobuf_unittest::TestOneof2::_i_give_permission_to_break_this_code_default_bar_cord_.get());
  }
  clear_bar();
  if (bar_cord) {
    set_has_bar_cord();
    bar_.bar_cord_.UnsafeArenaSetAllocated(&::protobuf_unittest::TestOneof2::_i_give_permission_to_break_this_code_default_bar_cord_.get(), bar_cord, GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf_unittest.TestOneof2.bar_cord)
}

// optional string bar_string_piece = 15 [default = "SPIECE", ctype = STRING_PIECE];
inline bool TestOneof2::has_bar_string_piece() const {
  return bar_case() == kBarStringPiece;
}
inline void TestOneof2::set_has_bar_string_piece() {
  _oneof_case_[1] = kBarStringPiece;
}
inline void TestOneof2::clear_bar_string_piece() {
  if (has_bar_string_piece()) {
    bar_.bar_string_piece_.Destroy(&::protobuf_unittest::TestOneof2::_i_give_permission_to_break_this_code_default_bar_string_piece_.get(),
        GetArenaNoVirtual());
    clear_has_bar();
  }
}
inline const ::std::string& TestOneof2::bar_string_piece() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestOneof2.bar_string_piece)
  if (has_bar_string_piece()) {
    return bar_.bar_string_piece_.Get();
  }
  return *&::protobuf_unittest::TestOneof2::_i_give_permission_to_break_this_code_default_bar_string_piece_.get();
}
inline void TestOneof2::set_bar_string_piece(const ::std::string& value) {
  if (!has_bar_string_piece()) {
    clear_bar();
    set_has_bar_string_piece();
    bar_.bar_string_piece_.UnsafeSetDefault(&::protobuf_unittest::TestOneof2::_i_give_permission_to_break_this_code_default_bar_string_piece_.get());
  }
  bar_.bar_string_piece_.Set(&::protobuf_unittest::TestOneof2::_i_give_permission_to_break_this_code_default_bar_string_piece_.get(), value,
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestOneof2.bar_string_piece)
}
#if LANG_CXX11
inline void TestOneof2::set_bar_string_piece(::std::string&& value) {
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestOneof2.bar_string_piece)
  if (!has_bar_string_piece()) {
    clear_bar();
    set_has_bar_string_piece();
    bar_.bar_string_piece_.UnsafeSetDefault(&::protobuf_unittest::TestOneof2::_i_give_permission_to_break_this_code_default_bar_string_piece_.get());
  }
  bar_.bar_string_piece_.Set(
    &::protobuf_unittest::TestOneof2::_i_give_permission_to_break_this_code_default_bar_string_piece_.get(), ::std::move(value), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_rvalue:protobuf_unittest.TestOneof2.bar_string_piece)
}
#endif
inline void TestOneof2::set_bar_string_piece(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  if (!has_bar_string_piece()) {
    clear_bar();
    set_has_bar_string_piece();
    bar_.bar_string_piece_.UnsafeSetDefault(&::protobuf_unittest::TestOneof2::_i_give_permission_to_break_this_code_default_bar_string_piece_.get());
  }
  bar_.bar_string_piece_.Set(&::protobuf_unittest::TestOneof2::_i_give_permission_to_break_this_code_default_bar_string_piece_.get(),
      ::std::string(value), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_char:protobuf_unittest.TestOneof2.bar_string_piece)
}
inline void TestOneof2::set_bar_string_piece(const char* value,
                             size_t size) {
  if (!has_bar_string_piece()) {
    clear_bar();
    set_has_bar_string_piece();
    bar_.bar_string_piece_.UnsafeSetDefault(&::protobuf_unittest::TestOneof2::_i_give_permission_to_break_this_code_default_bar_string_piece_.get());
  }
  bar_.bar_string_piece_.Set(
      &::protobuf_unittest::TestOneof2::_i_give_permission_to_break_this_code_default_bar_string_piece_.get(), ::std::string(
      reinterpret_cast<const char*>(value), size),
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_pointer:protobuf_unittest.TestOneof2.bar_string_piece)
}
inline ::std::string* TestOneof2::mutable_bar_string_piece() {
  if (!has_bar_string_piece()) {
    clear_bar();
    set_has_bar_string_piece();
    bar_.bar_string_piece_.UnsafeSetDefault(&::protobuf_unittest::TestOneof2::_i_give_permission_to_break_this_code_default_bar_string_piece_.get());
  }
  return bar_.bar_string_piece_.Mutable(&::protobuf_unittest::TestOneof2::_i_give_permission_to_break_this_code_default_bar_string_piece_.get(),
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestOneof2.bar_string_piece)
}
inline ::std::string* TestOneof2::release_bar_string_piece() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestOneof2.bar_string_piece)
  if (has_bar_string_piece()) {
    clear_has_bar();
    return bar_.bar_string_piece_.Release(&::protobuf_unittest::TestOneof2::_i_give_permission_to_break_this_code_default_bar_string_piece_.get(),
        GetArenaNoVirtual());
  } else {
    return NULL;
  }
}
inline void TestOneof2::set_allocated_bar_string_piece(::std::string* bar_string_piece) {
  if (!has_bar_string_piece()) {
    bar_.bar_string_piece_.UnsafeSetDefault(&::protobuf_unittest::TestOneof2::_i_give_permission_to_break_this_code_default_bar_string_piece_.get());
  }
  clear_bar();
  if (bar_string_piece != NULL) {
    set_has_bar_string_piece();
    bar_.bar_string_piece_.SetAllocated(&::protobuf_unittest::TestOneof2::_i_give_permission_to_break_this_code_default_bar_string_piece_.get(), bar_string_piece,
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestOneof2.bar_string_piece)
}
inline ::std::string* TestOneof2::unsafe_arena_release_bar_string_piece() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestOneof2.bar_string_piece)
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (has_bar_string_piece()) {
    clear_has_bar();
    return bar_.bar_string_piece_.UnsafeArenaRelease(
        &::protobuf_unittest::TestOneof2::_i_give_permission_to_break_this_code_default_bar_string_piece_.get(), GetArenaNoVirtual());
  } else {
    return NULL;
  }
}
inline void TestOneof2::unsafe_arena_set_allocated_bar_string_piece(::std::string* bar_string_piece) {
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (!has_bar_string_piece()) {
    bar_.bar_string_piece_.UnsafeSetDefault(&::protobuf_unittest::TestOneof2::_i_give_permission_to_break_this_code_default_bar_string_piece_.get());
  }
  clear_bar();
  if (bar_string_piece) {
    set_has_bar_string_piece();
    bar_.bar_string_piece_.UnsafeArenaSetAllocated(&::protobuf_unittest::TestOneof2::_i_give_permission_to_break_this_code_default_bar_string_piece_.get(), bar_string_piece, GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf_unittest.TestOneof2.bar_string_piece)
}

// optional bytes bar_bytes = 16 [default = "BYTES"];
inline bool TestOneof2::has_bar_bytes() const {
  return bar_case() == kBarBytes;
}
inline void TestOneof2::set_has_bar_bytes() {
  _oneof_case_[1] = kBarBytes;
}
inline void TestOneof2::clear_bar_bytes() {
  if (has_bar_bytes()) {
    bar_.bar_bytes_.Destroy(&::protobuf_unittest::TestOneof2::_i_give_permission_to_break_this_code_default_bar_bytes_.get(),
        GetArenaNoVirtual());
    clear_has_bar();
  }
}
inline const ::std::string& TestOneof2::bar_bytes() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestOneof2.bar_bytes)
  if (has_bar_bytes()) {
    return bar_.bar_bytes_.Get();
  }
  return *&::protobuf_unittest::TestOneof2::_i_give_permission_to_break_this_code_default_bar_bytes_.get();
}
inline void TestOneof2::set_bar_bytes(const ::std::string& value) {
  if (!has_bar_bytes()) {
    clear_bar();
    set_has_bar_bytes();
    bar_.bar_bytes_.UnsafeSetDefault(&::protobuf_unittest::TestOneof2::_i_give_permission_to_break_this_code_default_bar_bytes_.get());
  }
  bar_.bar_bytes_.Set(&::protobuf_unittest::TestOneof2::_i_give_permission_to_break_this_code_default_bar_bytes_.get(), value,
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestOneof2.bar_bytes)
}
#if LANG_CXX11
inline void TestOneof2::set_bar_bytes(::std::string&& value) {
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestOneof2.bar_bytes)
  if (!has_bar_bytes()) {
    clear_bar();
    set_has_bar_bytes();
    bar_.bar_bytes_.UnsafeSetDefault(&::protobuf_unittest::TestOneof2::_i_give_permission_to_break_this_code_default_bar_bytes_.get());
  }
  bar_.bar_bytes_.Set(
    &::protobuf_unittest::TestOneof2::_i_give_permission_to_break_this_code_default_bar_bytes_.get(), ::std::move(value), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_rvalue:protobuf_unittest.TestOneof2.bar_bytes)
}
#endif
inline void TestOneof2::set_bar_bytes(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  if (!has_bar_bytes()) {
    clear_bar();
    set_has_bar_bytes();
    bar_.bar_bytes_.UnsafeSetDefault(&::protobuf_unittest::TestOneof2::_i_give_permission_to_break_this_code_default_bar_bytes_.get());
  }
  bar_.bar_bytes_.Set(&::protobuf_unittest::TestOneof2::_i_give_permission_to_break_this_code_default_bar_bytes_.get(),
      ::std::string(value), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_char:protobuf_unittest.TestOneof2.bar_bytes)
}
inline void TestOneof2::set_bar_bytes(const void* value,
                             size_t size) {
  if (!has_bar_bytes()) {
    clear_bar();
    set_has_bar_bytes();
    bar_.bar_bytes_.UnsafeSetDefault(&::protobuf_unittest::TestOneof2::_i_give_permission_to_break_this_code_default_bar_bytes_.get());
  }
  bar_.bar_bytes_.Set(
      &::protobuf_unittest::TestOneof2::_i_give_permission_to_break_this_code_default_bar_bytes_.get(), ::std::string(
      reinterpret_cast<const char*>(value), size),
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_pointer:protobuf_unittest.TestOneof2.bar_bytes)
}
inline ::std::string* TestOneof2::mutable_bar_bytes() {
  if (!has_bar_bytes()) {
    clear_bar();
    set_has_bar_bytes();
    bar_.bar_bytes_.UnsafeSetDefault(&::protobuf_unittest::TestOneof2::_i_give_permission_to_break_this_code_default_bar_bytes_.get());
  }
  return bar_.bar_bytes_.Mutable(&::protobuf_unittest::TestOneof2::_i_give_permission_to_break_this_code_default_bar_bytes_.get(),
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestOneof2.bar_bytes)
}
inline ::std::string* TestOneof2::release_bar_bytes() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestOneof2.bar_bytes)
  if (has_bar_bytes()) {
    clear_has_bar();
    return bar_.bar_bytes_.Release(&::protobuf_unittest::TestOneof2::_i_give_permission_to_break_this_code_default_bar_bytes_.get(),
        GetArenaNoVirtual());
  } else {
    return NULL;
  }
}
inline void TestOneof2::set_allocated_bar_bytes(::std::string* bar_bytes) {
  if (!has_bar_bytes()) {
    bar_.bar_bytes_.UnsafeSetDefault(&::protobuf_unittest::TestOneof2::_i_give_permission_to_break_this_code_default_bar_bytes_.get());
  }
  clear_bar();
  if (bar_bytes != NULL) {
    set_has_bar_bytes();
    bar_.bar_bytes_.SetAllocated(&::protobuf_unittest::TestOneof2::_i_give_permission_to_break_this_code_default_bar_bytes_.get(), bar_bytes,
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestOneof2.bar_bytes)
}
inline ::std::string* TestOneof2::unsafe_arena_release_bar_bytes() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestOneof2.bar_bytes)
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (has_bar_bytes()) {
    clear_has_bar();
    return bar_.bar_bytes_.UnsafeArenaRelease(
        &::protobuf_unittest::TestOneof2::_i_give_permission_to_break_this_code_default_bar_bytes_.get(), GetArenaNoVirtual());
  } else {
    return NULL;
  }
}
inline void TestOneof2::unsafe_arena_set_allocated_bar_bytes(::std::string* bar_bytes) {
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (!has_bar_bytes()) {
    bar_.bar_bytes_.UnsafeSetDefault(&::protobuf_unittest::TestOneof2::_i_give_permission_to_break_this_code_default_bar_bytes_.get());
  }
  clear_bar();
  if (bar_bytes) {
    set_has_bar_bytes();
    bar_.bar_bytes_.UnsafeArenaSetAllocated(&::protobuf_unittest::TestOneof2::_i_give_permission_to_break_this_code_default_bar_bytes_.get(), bar_bytes, GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf_unittest.TestOneof2.bar_bytes)
}

// optional .protobuf_unittest.TestOneof2.NestedEnum bar_enum = 17 [default = BAR];
inline bool TestOneof2::has_bar_enum() const {
  return bar_case() == kBarEnum;
}
inline void TestOneof2::set_has_bar_enum() {
  _oneof_case_[1] = kBarEnum;
}
inline void TestOneof2::clear_bar_enum() {
  if (has_bar_enum()) {
    bar_.bar_enum_ = 2;
    clear_has_bar();
  }
}
inline ::protobuf_unittest::TestOneof2_NestedEnum TestOneof2::bar_enum() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestOneof2.bar_enum)
  if (has_bar_enum()) {
    return static_cast< ::protobuf_unittest::TestOneof2_NestedEnum >(bar_.bar_enum_);
  }
  return static_cast< ::protobuf_unittest::TestOneof2_NestedEnum >(2);
}
inline void TestOneof2::set_bar_enum(::protobuf_unittest::TestOneof2_NestedEnum value) {
  assert(::protobuf_unittest::TestOneof2_NestedEnum_IsValid(value));
  if (!has_bar_enum()) {
    clear_bar();
    set_has_bar_enum();
  }
  bar_.bar_enum_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestOneof2.bar_enum)
}

// optional int32 baz_int = 18;
inline bool TestOneof2::has_baz_int() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void TestOneof2::set_has_baz_int() {
  _has_bits_[0] |= 0x00000002u;
}
inline void TestOneof2::clear_has_baz_int() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void TestOneof2::clear_baz_int() {
  baz_int_ = 0;
  clear_has_baz_int();
}
inline ::google::protobuf::int32 TestOneof2::baz_int() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestOneof2.baz_int)
  return baz_int_;
}
inline void TestOneof2::set_baz_int(::google::protobuf::int32 value) {
  set_has_baz_int();
  baz_int_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestOneof2.baz_int)
}

// optional string baz_string = 19 [default = "BAZ"];
inline bool TestOneof2::has_baz_string() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TestOneof2::set_has_baz_string() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TestOneof2::clear_has_baz_string() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TestOneof2::clear_baz_string() {
  baz_string_.ClearToDefault(&::protobuf_unittest::TestOneof2::_i_give_permission_to_break_this_code_default_baz_string_.get(), GetArenaNoVirtual());
  clear_has_baz_string();
}
inline const ::std::string& TestOneof2::baz_string() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestOneof2.baz_string)
  return baz_string_.Get();
}
inline void TestOneof2::set_baz_string(const ::std::string& value) {
  set_has_baz_string();
  baz_string_.Set(&::protobuf_unittest::TestOneof2::_i_give_permission_to_break_this_code_default_baz_string_.get(), value, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestOneof2.baz_string)
}
#if LANG_CXX11
inline void TestOneof2::set_baz_string(::std::string&& value) {
  set_has_baz_string();
  baz_string_.Set(
    &::protobuf_unittest::TestOneof2::_i_give_permission_to_break_this_code_default_baz_string_.get(), ::std::move(value), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_rvalue:protobuf_unittest.TestOneof2.baz_string)
}
#endif
inline void TestOneof2::set_baz_string(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_baz_string();
  baz_string_.Set(&::protobuf_unittest::TestOneof2::_i_give_permission_to_break_this_code_default_baz_string_.get(), ::std::string(value),
              GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_char:protobuf_unittest.TestOneof2.baz_string)
}
inline void TestOneof2::set_baz_string(const char* value,
    size_t size) {
  set_has_baz_string();
  baz_string_.Set(&::protobuf_unittest::TestOneof2::_i_give_permission_to_break_this_code_default_baz_string_.get(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_pointer:protobuf_unittest.TestOneof2.baz_string)
}
inline ::std::string* TestOneof2::mutable_baz_string() {
  set_has_baz_string();
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestOneof2.baz_string)
  return baz_string_.Mutable(&::protobuf_unittest::TestOneof2::_i_give_permission_to_break_this_code_default_baz_string_.get(), GetArenaNoVirtual());
}
inline ::std::string* TestOneof2::release_baz_string() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestOneof2.baz_string)
  if (!has_baz_string()) {
    return NULL;
  }
  clear_has_baz_string();
  return baz_string_.ReleaseNonDefault(&::protobuf_unittest::TestOneof2::_i_give_permission_to_break_this_code_default_baz_string_.get(), GetArenaNoVirtual());
}
inline void TestOneof2::set_allocated_baz_string(::std::string* baz_string) {
  if (baz_string != NULL) {
    set_has_baz_string();
  } else {
    clear_has_baz_string();
  }
  baz_string_.SetAllocated(&::protobuf_unittest::TestOneof2::_i_give_permission_to_break_this_code_default_baz_string_.get(), baz_string,
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestOneof2.baz_string)
}
inline ::std::string* TestOneof2::unsafe_arena_release_baz_string() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestOneof2.baz_string)
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  clear_has_baz_string();
  return baz_string_.UnsafeArenaRelease(&::protobuf_unittest::TestOneof2::_i_give_permission_to_break_this_code_default_baz_string_.get(),
      GetArenaNoVirtual());
}
inline void TestOneof2::unsafe_arena_set_allocated_baz_string(
    ::std::string* baz_string) {
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (baz_string != NULL) {
    set_has_baz_string();
  } else {
    clear_has_baz_string();
  }
  baz_string_.UnsafeArenaSetAllocated(&::protobuf_unittest::TestOneof2::_i_give_permission_to_break_this_code_default_baz_string_.get(),
      baz_string, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf_unittest.TestOneof2.baz_string)
}

inline bool TestOneof2::has_foo() const {
  return foo_case() != FOO_NOT_SET;
}
inline void TestOneof2::clear_has_foo() {
  _oneof_case_[0] = FOO_NOT_SET;
}
inline bool TestOneof2::has_bar() const {
  return bar_case() != BAR_NOT_SET;
}
inline void TestOneof2::clear_has_bar() {
  _oneof_case_[1] = BAR_NOT_SET;
}
inline TestOneof2::FooCase TestOneof2::foo_case() const {
  return TestOneof2::FooCase(_oneof_case_[0]);
}
inline TestOneof2::BarCase TestOneof2::bar_case() const {
  return TestOneof2::BarCase(_oneof_case_[1]);
}
// -------------------------------------------------------------------

// TestRequiredOneof_NestedMessage

// required double required_double = 1;
inline bool TestRequiredOneof_NestedMessage::has_required_double() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TestRequiredOneof_NestedMessage::set_has_required_double() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TestRequiredOneof_NestedMessage::clear_has_required_double() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TestRequiredOneof_NestedMessage::clear_required_double() {
  required_double_ = 0;
  clear_has_required_double();
}
inline double TestRequiredOneof_NestedMessage::required_double() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestRequiredOneof.NestedMessage.required_double)
  return required_double_;
}
inline void TestRequiredOneof_NestedMessage::set_required_double(double value) {
  set_has_required_double();
  required_double_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestRequiredOneof.NestedMessage.required_double)
}

// -------------------------------------------------------------------

// TestRequiredOneof

// optional int32 foo_int = 1;
inline bool TestRequiredOneof::has_foo_int() const {
  return foo_case() == kFooInt;
}
inline void TestRequiredOneof::set_has_foo_int() {
  _oneof_case_[0] = kFooInt;
}
inline void TestRequiredOneof::clear_foo_int() {
  if (has_foo_int()) {
    foo_.foo_int_ = 0;
    clear_has_foo();
  }
}
inline ::google::protobuf::int32 TestRequiredOneof::foo_int() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestRequiredOneof.foo_int)
  if (has_foo_int()) {
    return foo_.foo_int_;
  }
  return 0;
}
inline void TestRequiredOneof::set_foo_int(::google::protobuf::int32 value) {
  if (!has_foo_int()) {
    clear_foo();
    set_has_foo_int();
  }
  foo_.foo_int_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestRequiredOneof.foo_int)
}

// optional string foo_string = 2;
inline bool TestRequiredOneof::has_foo_string() const {
  return foo_case() == kFooString;
}
inline void TestRequiredOneof::set_has_foo_string() {
  _oneof_case_[0] = kFooString;
}
inline void TestRequiredOneof::clear_foo_string() {
  if (has_foo_string()) {
    foo_.foo_string_.Destroy(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
        GetArenaNoVirtual());
    clear_has_foo();
  }
}
inline const ::std::string& TestRequiredOneof::foo_string() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestRequiredOneof.foo_string)
  if (has_foo_string()) {
    return foo_.foo_string_.Get();
  }
  return *&::google::protobuf::internal::GetEmptyStringAlreadyInited();
}
inline void TestRequiredOneof::set_foo_string(const ::std::string& value) {
  if (!has_foo_string()) {
    clear_foo();
    set_has_foo_string();
    foo_.foo_string_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  foo_.foo_string_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value,
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestRequiredOneof.foo_string)
}
#if LANG_CXX11
inline void TestRequiredOneof::set_foo_string(::std::string&& value) {
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestRequiredOneof.foo_string)
  if (!has_foo_string()) {
    clear_foo();
    set_has_foo_string();
    foo_.foo_string_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  foo_.foo_string_.Set(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_rvalue:protobuf_unittest.TestRequiredOneof.foo_string)
}
#endif
inline void TestRequiredOneof::set_foo_string(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  if (!has_foo_string()) {
    clear_foo();
    set_has_foo_string();
    foo_.foo_string_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  foo_.foo_string_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(value), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_char:protobuf_unittest.TestRequiredOneof.foo_string)
}
inline void TestRequiredOneof::set_foo_string(const char* value,
                             size_t size) {
  if (!has_foo_string()) {
    clear_foo();
    set_has_foo_string();
    foo_.foo_string_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  foo_.foo_string_.Set(
      &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size),
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_pointer:protobuf_unittest.TestRequiredOneof.foo_string)
}
inline ::std::string* TestRequiredOneof::mutable_foo_string() {
  if (!has_foo_string()) {
    clear_foo();
    set_has_foo_string();
    foo_.foo_string_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  return foo_.foo_string_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestRequiredOneof.foo_string)
}
inline ::std::string* TestRequiredOneof::release_foo_string() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestRequiredOneof.foo_string)
  if (has_foo_string()) {
    clear_has_foo();
    return foo_.foo_string_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
        GetArenaNoVirtual());
  } else {
    return NULL;
  }
}
inline void TestRequiredOneof::set_allocated_foo_string(::std::string* foo_string) {
  if (!has_foo_string()) {
    foo_.foo_string_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  clear_foo();
  if (foo_string != NULL) {
    set_has_foo_string();
    foo_.foo_string_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), foo_string,
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestRequiredOneof.foo_string)
}
inline ::std::string* TestRequiredOneof::unsafe_arena_release_foo_string() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestRequiredOneof.foo_string)
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (has_foo_string()) {
    clear_has_foo();
    return foo_.foo_string_.UnsafeArenaRelease(
        &::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
  } else {
    return NULL;
  }
}
inline void TestRequiredOneof::unsafe_arena_set_allocated_foo_string(::std::string* foo_string) {
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (!has_foo_string()) {
    foo_.foo_string_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  clear_foo();
  if (foo_string) {
    set_has_foo_string();
    foo_.foo_string_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), foo_string, GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf_unittest.TestRequiredOneof.foo_string)
}

// optional .protobuf_unittest.TestRequiredOneof.NestedMessage foo_message = 3;
inline bool TestRequiredOneof::has_foo_message() const {
  return foo_case() == kFooMessage;
}
inline void TestRequiredOneof::set_has_foo_message() {
  _oneof_case_[0] = kFooMessage;
}
inline void TestRequiredOneof::clear_foo_message() {
  if (has_foo_message()) {
    if (GetArenaNoVirtual() == NULL) {
      delete foo_.foo_message_;
    }
    clear_has_foo();
  }
}
inline const ::protobuf_unittest::TestRequiredOneof_NestedMessage& TestRequiredOneof::_internal_foo_message() const {
  return *foo_.foo_message_;
}
inline ::protobuf_unittest::TestRequiredOneof_NestedMessage* TestRequiredOneof::release_foo_message() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestRequiredOneof.foo_message)
  if (has_foo_message()) {
    clear_has_foo();
      ::protobuf_unittest::TestRequiredOneof_NestedMessage* temp = foo_.foo_message_;
    if (GetArenaNoVirtual() != NULL) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    foo_.foo_message_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::protobuf_unittest::TestRequiredOneof_NestedMessage& TestRequiredOneof::foo_message() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestRequiredOneof.foo_message)
  return has_foo_message()
      ? *foo_.foo_message_
      : *reinterpret_cast< ::protobuf_unittest::TestRequiredOneof_NestedMessage*>(&::protobuf_unittest::_TestRequiredOneof_NestedMessage_default_instance_);
}
inline ::protobuf_unittest::TestRequiredOneof_NestedMessage* TestRequiredOneof::unsafe_arena_release_foo_message() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestRequiredOneof.foo_message)
  if (has_foo_message()) {
    clear_has_foo();
    ::protobuf_unittest::TestRequiredOneof_NestedMessage* temp = foo_.foo_message_;
    foo_.foo_message_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline void TestRequiredOneof::unsafe_arena_set_allocated_foo_message(::protobuf_unittest::TestRequiredOneof_NestedMessage* foo_message) {
  clear_foo();
  if (foo_message) {
    set_has_foo_message();
    foo_.foo_message_ = foo_message;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf_unittest.TestRequiredOneof.foo_message)
}
inline ::protobuf_unittest::TestRequiredOneof_NestedMessage* TestRequiredOneof::mutable_foo_message() {
  if (!has_foo_message()) {
    clear_foo();
    set_has_foo_message();
    foo_.foo_message_ = CreateMaybeMessage< ::protobuf_unittest::TestRequiredOneof_NestedMessage >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestRequiredOneof.foo_message)
  return foo_.foo_message_;
}

inline bool TestRequiredOneof::has_foo() const {
  return foo_case() != FOO_NOT_SET;
}
inline void TestRequiredOneof::clear_has_foo() {
  _oneof_case_[0] = FOO_NOT_SET;
}
inline TestRequiredOneof::FooCase TestRequiredOneof::foo_case() const {
  return TestRequiredOneof::FooCase(_oneof_case_[0]);
}
// -------------------------------------------------------------------

// TestPackedTypes

// repeated int32 packed_int32 = 90 [packed = true];
inline int TestPackedTypes::packed_int32_size() const {
  return packed_int32_.size();
}
inline void TestPackedTypes::clear_packed_int32() {
  packed_int32_.Clear();
}
inline ::google::protobuf::int32 TestPackedTypes::packed_int32(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestPackedTypes.packed_int32)
  return packed_int32_.Get(index);
}
inline void TestPackedTypes::set_packed_int32(int index, ::google::protobuf::int32 value) {
  packed_int32_.Set(index, value);
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestPackedTypes.packed_int32)
}
inline void TestPackedTypes::add_packed_int32(::google::protobuf::int32 value) {
  packed_int32_.Add(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestPackedTypes.packed_int32)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
TestPackedTypes::packed_int32() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestPackedTypes.packed_int32)
  return packed_int32_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
TestPackedTypes::mutable_packed_int32() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestPackedTypes.packed_int32)
  return &packed_int32_;
}

// repeated int64 packed_int64 = 91 [packed = true];
inline int TestPackedTypes::packed_int64_size() const {
  return packed_int64_.size();
}
inline void TestPackedTypes::clear_packed_int64() {
  packed_int64_.Clear();
}
inline ::google::protobuf::int64 TestPackedTypes::packed_int64(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestPackedTypes.packed_int64)
  return packed_int64_.Get(index);
}
inline void TestPackedTypes::set_packed_int64(int index, ::google::protobuf::int64 value) {
  packed_int64_.Set(index, value);
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestPackedTypes.packed_int64)
}
inline void TestPackedTypes::add_packed_int64(::google::protobuf::int64 value) {
  packed_int64_.Add(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestPackedTypes.packed_int64)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
TestPackedTypes::packed_int64() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestPackedTypes.packed_int64)
  return packed_int64_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
TestPackedTypes::mutable_packed_int64() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestPackedTypes.packed_int64)
  return &packed_int64_;
}

// repeated uint32 packed_uint32 = 92 [packed = true];
inline int TestPackedTypes::packed_uint32_size() const {
  return packed_uint32_.size();
}
inline void TestPackedTypes::clear_packed_uint32() {
  packed_uint32_.Clear();
}
inline ::google::protobuf::uint32 TestPackedTypes::packed_uint32(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestPackedTypes.packed_uint32)
  return packed_uint32_.Get(index);
}
inline void TestPackedTypes::set_packed_uint32(int index, ::google::protobuf::uint32 value) {
  packed_uint32_.Set(index, value);
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestPackedTypes.packed_uint32)
}
inline void TestPackedTypes::add_packed_uint32(::google::protobuf::uint32 value) {
  packed_uint32_.Add(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestPackedTypes.packed_uint32)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
TestPackedTypes::packed_uint32() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestPackedTypes.packed_uint32)
  return packed_uint32_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
TestPackedTypes::mutable_packed_uint32() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestPackedTypes.packed_uint32)
  return &packed_uint32_;
}

// repeated uint64 packed_uint64 = 93 [packed = true];
inline int TestPackedTypes::packed_uint64_size() const {
  return packed_uint64_.size();
}
inline void TestPackedTypes::clear_packed_uint64() {
  packed_uint64_.Clear();
}
inline ::google::protobuf::uint64 TestPackedTypes::packed_uint64(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestPackedTypes.packed_uint64)
  return packed_uint64_.Get(index);
}
inline void TestPackedTypes::set_packed_uint64(int index, ::google::protobuf::uint64 value) {
  packed_uint64_.Set(index, value);
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestPackedTypes.packed_uint64)
}
inline void TestPackedTypes::add_packed_uint64(::google::protobuf::uint64 value) {
  packed_uint64_.Add(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestPackedTypes.packed_uint64)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >&
TestPackedTypes::packed_uint64() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestPackedTypes.packed_uint64)
  return packed_uint64_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >*
TestPackedTypes::mutable_packed_uint64() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestPackedTypes.packed_uint64)
  return &packed_uint64_;
}

// repeated sint32 packed_sint32 = 94 [packed = true];
inline int TestPackedTypes::packed_sint32_size() const {
  return packed_sint32_.size();
}
inline void TestPackedTypes::clear_packed_sint32() {
  packed_sint32_.Clear();
}
inline ::google::protobuf::int32 TestPackedTypes::packed_sint32(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestPackedTypes.packed_sint32)
  return packed_sint32_.Get(index);
}
inline void TestPackedTypes::set_packed_sint32(int index, ::google::protobuf::int32 value) {
  packed_sint32_.Set(index, value);
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestPackedTypes.packed_sint32)
}
inline void TestPackedTypes::add_packed_sint32(::google::protobuf::int32 value) {
  packed_sint32_.Add(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestPackedTypes.packed_sint32)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
TestPackedTypes::packed_sint32() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestPackedTypes.packed_sint32)
  return packed_sint32_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
TestPackedTypes::mutable_packed_sint32() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestPackedTypes.packed_sint32)
  return &packed_sint32_;
}

// repeated sint64 packed_sint64 = 95 [packed = true];
inline int TestPackedTypes::packed_sint64_size() const {
  return packed_sint64_.size();
}
inline void TestPackedTypes::clear_packed_sint64() {
  packed_sint64_.Clear();
}
inline ::google::protobuf::int64 TestPackedTypes::packed_sint64(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestPackedTypes.packed_sint64)
  return packed_sint64_.Get(index);
}
inline void TestPackedTypes::set_packed_sint64(int index, ::google::protobuf::int64 value) {
  packed_sint64_.Set(index, value);
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestPackedTypes.packed_sint64)
}
inline void TestPackedTypes::add_packed_sint64(::google::protobuf::int64 value) {
  packed_sint64_.Add(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestPackedTypes.packed_sint64)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
TestPackedTypes::packed_sint64() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestPackedTypes.packed_sint64)
  return packed_sint64_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
TestPackedTypes::mutable_packed_sint64() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestPackedTypes.packed_sint64)
  return &packed_sint64_;
}

// repeated fixed32 packed_fixed32 = 96 [packed = true];
inline int TestPackedTypes::packed_fixed32_size() const {
  return packed_fixed32_.size();
}
inline void TestPackedTypes::clear_packed_fixed32() {
  packed_fixed32_.Clear();
}
inline ::google::protobuf::uint32 TestPackedTypes::packed_fixed32(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestPackedTypes.packed_fixed32)
  return packed_fixed32_.Get(index);
}
inline void TestPackedTypes::set_packed_fixed32(int index, ::google::protobuf::uint32 value) {
  packed_fixed32_.Set(index, value);
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestPackedTypes.packed_fixed32)
}
inline void TestPackedTypes::add_packed_fixed32(::google::protobuf::uint32 value) {
  packed_fixed32_.Add(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestPackedTypes.packed_fixed32)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
TestPackedTypes::packed_fixed32() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestPackedTypes.packed_fixed32)
  return packed_fixed32_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
TestPackedTypes::mutable_packed_fixed32() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestPackedTypes.packed_fixed32)
  return &packed_fixed32_;
}

// repeated fixed64 packed_fixed64 = 97 [packed = true];
inline int TestPackedTypes::packed_fixed64_size() const {
  return packed_fixed64_.size();
}
inline void TestPackedTypes::clear_packed_fixed64() {
  packed_fixed64_.Clear();
}
inline ::google::protobuf::uint64 TestPackedTypes::packed_fixed64(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestPackedTypes.packed_fixed64)
  return packed_fixed64_.Get(index);
}
inline void TestPackedTypes::set_packed_fixed64(int index, ::google::protobuf::uint64 value) {
  packed_fixed64_.Set(index, value);
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestPackedTypes.packed_fixed64)
}
inline void TestPackedTypes::add_packed_fixed64(::google::protobuf::uint64 value) {
  packed_fixed64_.Add(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestPackedTypes.packed_fixed64)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >&
TestPackedTypes::packed_fixed64() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestPackedTypes.packed_fixed64)
  return packed_fixed64_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >*
TestPackedTypes::mutable_packed_fixed64() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestPackedTypes.packed_fixed64)
  return &packed_fixed64_;
}

// repeated sfixed32 packed_sfixed32 = 98 [packed = true];
inline int TestPackedTypes::packed_sfixed32_size() const {
  return packed_sfixed32_.size();
}
inline void TestPackedTypes::clear_packed_sfixed32() {
  packed_sfixed32_.Clear();
}
inline ::google::protobuf::int32 TestPackedTypes::packed_sfixed32(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestPackedTypes.packed_sfixed32)
  return packed_sfixed32_.Get(index);
}
inline void TestPackedTypes::set_packed_sfixed32(int index, ::google::protobuf::int32 value) {
  packed_sfixed32_.Set(index, value);
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestPackedTypes.packed_sfixed32)
}
inline void TestPackedTypes::add_packed_sfixed32(::google::protobuf::int32 value) {
  packed_sfixed32_.Add(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestPackedTypes.packed_sfixed32)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
TestPackedTypes::packed_sfixed32() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestPackedTypes.packed_sfixed32)
  return packed_sfixed32_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
TestPackedTypes::mutable_packed_sfixed32() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestPackedTypes.packed_sfixed32)
  return &packed_sfixed32_;
}

// repeated sfixed64 packed_sfixed64 = 99 [packed = true];
inline int TestPackedTypes::packed_sfixed64_size() const {
  return packed_sfixed64_.size();
}
inline void TestPackedTypes::clear_packed_sfixed64() {
  packed_sfixed64_.Clear();
}
inline ::google::protobuf::int64 TestPackedTypes::packed_sfixed64(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestPackedTypes.packed_sfixed64)
  return packed_sfixed64_.Get(index);
}
inline void TestPackedTypes::set_packed_sfixed64(int index, ::google::protobuf::int64 value) {
  packed_sfixed64_.Set(index, value);
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestPackedTypes.packed_sfixed64)
}
inline void TestPackedTypes::add_packed_sfixed64(::google::protobuf::int64 value) {
  packed_sfixed64_.Add(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestPackedTypes.packed_sfixed64)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
TestPackedTypes::packed_sfixed64() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestPackedTypes.packed_sfixed64)
  return packed_sfixed64_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
TestPackedTypes::mutable_packed_sfixed64() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestPackedTypes.packed_sfixed64)
  return &packed_sfixed64_;
}

// repeated float packed_float = 100 [packed = true];
inline int TestPackedTypes::packed_float_size() const {
  return packed_float_.size();
}
inline void TestPackedTypes::clear_packed_float() {
  packed_float_.Clear();
}
inline float TestPackedTypes::packed_float(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestPackedTypes.packed_float)
  return packed_float_.Get(index);
}
inline void TestPackedTypes::set_packed_float(int index, float value) {
  packed_float_.Set(index, value);
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestPackedTypes.packed_float)
}
inline void TestPackedTypes::add_packed_float(float value) {
  packed_float_.Add(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestPackedTypes.packed_float)
}
inline const ::google::protobuf::RepeatedField< float >&
TestPackedTypes::packed_float() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestPackedTypes.packed_float)
  return packed_float_;
}
inline ::google::protobuf::RepeatedField< float >*
TestPackedTypes::mutable_packed_float() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestPackedTypes.packed_float)
  return &packed_float_;
}

// repeated double packed_double = 101 [packed = true];
inline int TestPackedTypes::packed_double_size() const {
  return packed_double_.size();
}
inline void TestPackedTypes::clear_packed_double() {
  packed_double_.Clear();
}
inline double TestPackedTypes::packed_double(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestPackedTypes.packed_double)
  return packed_double_.Get(index);
}
inline void TestPackedTypes::set_packed_double(int index, double value) {
  packed_double_.Set(index, value);
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestPackedTypes.packed_double)
}
inline void TestPackedTypes::add_packed_double(double value) {
  packed_double_.Add(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestPackedTypes.packed_double)
}
inline const ::google::protobuf::RepeatedField< double >&
TestPackedTypes::packed_double() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestPackedTypes.packed_double)
  return packed_double_;
}
inline ::google::protobuf::RepeatedField< double >*
TestPackedTypes::mutable_packed_double() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestPackedTypes.packed_double)
  return &packed_double_;
}

// repeated bool packed_bool = 102 [packed = true];
inline int TestPackedTypes::packed_bool_size() const {
  return packed_bool_.size();
}
inline void TestPackedTypes::clear_packed_bool() {
  packed_bool_.Clear();
}
inline bool TestPackedTypes::packed_bool(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestPackedTypes.packed_bool)
  return packed_bool_.Get(index);
}
inline void TestPackedTypes::set_packed_bool(int index, bool value) {
  packed_bool_.Set(index, value);
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestPackedTypes.packed_bool)
}
inline void TestPackedTypes::add_packed_bool(bool value) {
  packed_bool_.Add(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestPackedTypes.packed_bool)
}
inline const ::google::protobuf::RepeatedField< bool >&
TestPackedTypes::packed_bool() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestPackedTypes.packed_bool)
  return packed_bool_;
}
inline ::google::protobuf::RepeatedField< bool >*
TestPackedTypes::mutable_packed_bool() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestPackedTypes.packed_bool)
  return &packed_bool_;
}

// repeated .protobuf_unittest.ForeignEnum packed_enum = 103 [packed = true];
inline int TestPackedTypes::packed_enum_size() const {
  return packed_enum_.size();
}
inline void TestPackedTypes::clear_packed_enum() {
  packed_enum_.Clear();
}
inline ::protobuf_unittest::ForeignEnum TestPackedTypes::packed_enum(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestPackedTypes.packed_enum)
  return static_cast< ::protobuf_unittest::ForeignEnum >(packed_enum_.Get(index));
}
inline void TestPackedTypes::set_packed_enum(int index, ::protobuf_unittest::ForeignEnum value) {
  assert(::protobuf_unittest::ForeignEnum_IsValid(value));
  packed_enum_.Set(index, value);
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestPackedTypes.packed_enum)
}
inline void TestPackedTypes::add_packed_enum(::protobuf_unittest::ForeignEnum value) {
  assert(::protobuf_unittest::ForeignEnum_IsValid(value));
  packed_enum_.Add(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestPackedTypes.packed_enum)
}
inline const ::google::protobuf::RepeatedField<int>&
TestPackedTypes::packed_enum() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestPackedTypes.packed_enum)
  return packed_enum_;
}
inline ::google::protobuf::RepeatedField<int>*
TestPackedTypes::mutable_packed_enum() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestPackedTypes.packed_enum)
  return &packed_enum_;
}

// -------------------------------------------------------------------

// TestUnpackedTypes

// repeated int32 unpacked_int32 = 90 [packed = false];
inline int TestUnpackedTypes::unpacked_int32_size() const {
  return unpacked_int32_.size();
}
inline void TestUnpackedTypes::clear_unpacked_int32() {
  unpacked_int32_.Clear();
}
inline ::google::protobuf::int32 TestUnpackedTypes::unpacked_int32(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestUnpackedTypes.unpacked_int32)
  return unpacked_int32_.Get(index);
}
inline void TestUnpackedTypes::set_unpacked_int32(int index, ::google::protobuf::int32 value) {
  unpacked_int32_.Set(index, value);
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestUnpackedTypes.unpacked_int32)
}
inline void TestUnpackedTypes::add_unpacked_int32(::google::protobuf::int32 value) {
  unpacked_int32_.Add(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestUnpackedTypes.unpacked_int32)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
TestUnpackedTypes::unpacked_int32() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestUnpackedTypes.unpacked_int32)
  return unpacked_int32_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
TestUnpackedTypes::mutable_unpacked_int32() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestUnpackedTypes.unpacked_int32)
  return &unpacked_int32_;
}

// repeated int64 unpacked_int64 = 91 [packed = false];
inline int TestUnpackedTypes::unpacked_int64_size() const {
  return unpacked_int64_.size();
}
inline void TestUnpackedTypes::clear_unpacked_int64() {
  unpacked_int64_.Clear();
}
inline ::google::protobuf::int64 TestUnpackedTypes::unpacked_int64(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestUnpackedTypes.unpacked_int64)
  return unpacked_int64_.Get(index);
}
inline void TestUnpackedTypes::set_unpacked_int64(int index, ::google::protobuf::int64 value) {
  unpacked_int64_.Set(index, value);
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestUnpackedTypes.unpacked_int64)
}
inline void TestUnpackedTypes::add_unpacked_int64(::google::protobuf::int64 value) {
  unpacked_int64_.Add(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestUnpackedTypes.unpacked_int64)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
TestUnpackedTypes::unpacked_int64() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestUnpackedTypes.unpacked_int64)
  return unpacked_int64_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
TestUnpackedTypes::mutable_unpacked_int64() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestUnpackedTypes.unpacked_int64)
  return &unpacked_int64_;
}

// repeated uint32 unpacked_uint32 = 92 [packed = false];
inline int TestUnpackedTypes::unpacked_uint32_size() const {
  return unpacked_uint32_.size();
}
inline void TestUnpackedTypes::clear_unpacked_uint32() {
  unpacked_uint32_.Clear();
}
inline ::google::protobuf::uint32 TestUnpackedTypes::unpacked_uint32(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestUnpackedTypes.unpacked_uint32)
  return unpacked_uint32_.Get(index);
}
inline void TestUnpackedTypes::set_unpacked_uint32(int index, ::google::protobuf::uint32 value) {
  unpacked_uint32_.Set(index, value);
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestUnpackedTypes.unpacked_uint32)
}
inline void TestUnpackedTypes::add_unpacked_uint32(::google::protobuf::uint32 value) {
  unpacked_uint32_.Add(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestUnpackedTypes.unpacked_uint32)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
TestUnpackedTypes::unpacked_uint32() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestUnpackedTypes.unpacked_uint32)
  return unpacked_uint32_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
TestUnpackedTypes::mutable_unpacked_uint32() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestUnpackedTypes.unpacked_uint32)
  return &unpacked_uint32_;
}

// repeated uint64 unpacked_uint64 = 93 [packed = false];
inline int TestUnpackedTypes::unpacked_uint64_size() const {
  return unpacked_uint64_.size();
}
inline void TestUnpackedTypes::clear_unpacked_uint64() {
  unpacked_uint64_.Clear();
}
inline ::google::protobuf::uint64 TestUnpackedTypes::unpacked_uint64(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestUnpackedTypes.unpacked_uint64)
  return unpacked_uint64_.Get(index);
}
inline void TestUnpackedTypes::set_unpacked_uint64(int index, ::google::protobuf::uint64 value) {
  unpacked_uint64_.Set(index, value);
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestUnpackedTypes.unpacked_uint64)
}
inline void TestUnpackedTypes::add_unpacked_uint64(::google::protobuf::uint64 value) {
  unpacked_uint64_.Add(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestUnpackedTypes.unpacked_uint64)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >&
TestUnpackedTypes::unpacked_uint64() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestUnpackedTypes.unpacked_uint64)
  return unpacked_uint64_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >*
TestUnpackedTypes::mutable_unpacked_uint64() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestUnpackedTypes.unpacked_uint64)
  return &unpacked_uint64_;
}

// repeated sint32 unpacked_sint32 = 94 [packed = false];
inline int TestUnpackedTypes::unpacked_sint32_size() const {
  return unpacked_sint32_.size();
}
inline void TestUnpackedTypes::clear_unpacked_sint32() {
  unpacked_sint32_.Clear();
}
inline ::google::protobuf::int32 TestUnpackedTypes::unpacked_sint32(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestUnpackedTypes.unpacked_sint32)
  return unpacked_sint32_.Get(index);
}
inline void TestUnpackedTypes::set_unpacked_sint32(int index, ::google::protobuf::int32 value) {
  unpacked_sint32_.Set(index, value);
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestUnpackedTypes.unpacked_sint32)
}
inline void TestUnpackedTypes::add_unpacked_sint32(::google::protobuf::int32 value) {
  unpacked_sint32_.Add(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestUnpackedTypes.unpacked_sint32)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
TestUnpackedTypes::unpacked_sint32() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestUnpackedTypes.unpacked_sint32)
  return unpacked_sint32_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
TestUnpackedTypes::mutable_unpacked_sint32() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestUnpackedTypes.unpacked_sint32)
  return &unpacked_sint32_;
}

// repeated sint64 unpacked_sint64 = 95 [packed = false];
inline int TestUnpackedTypes::unpacked_sint64_size() const {
  return unpacked_sint64_.size();
}
inline void TestUnpackedTypes::clear_unpacked_sint64() {
  unpacked_sint64_.Clear();
}
inline ::google::protobuf::int64 TestUnpackedTypes::unpacked_sint64(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestUnpackedTypes.unpacked_sint64)
  return unpacked_sint64_.Get(index);
}
inline void TestUnpackedTypes::set_unpacked_sint64(int index, ::google::protobuf::int64 value) {
  unpacked_sint64_.Set(index, value);
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestUnpackedTypes.unpacked_sint64)
}
inline void TestUnpackedTypes::add_unpacked_sint64(::google::protobuf::int64 value) {
  unpacked_sint64_.Add(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestUnpackedTypes.unpacked_sint64)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
TestUnpackedTypes::unpacked_sint64() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestUnpackedTypes.unpacked_sint64)
  return unpacked_sint64_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
TestUnpackedTypes::mutable_unpacked_sint64() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestUnpackedTypes.unpacked_sint64)
  return &unpacked_sint64_;
}

// repeated fixed32 unpacked_fixed32 = 96 [packed = false];
inline int TestUnpackedTypes::unpacked_fixed32_size() const {
  return unpacked_fixed32_.size();
}
inline void TestUnpackedTypes::clear_unpacked_fixed32() {
  unpacked_fixed32_.Clear();
}
inline ::google::protobuf::uint32 TestUnpackedTypes::unpacked_fixed32(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestUnpackedTypes.unpacked_fixed32)
  return unpacked_fixed32_.Get(index);
}
inline void TestUnpackedTypes::set_unpacked_fixed32(int index, ::google::protobuf::uint32 value) {
  unpacked_fixed32_.Set(index, value);
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestUnpackedTypes.unpacked_fixed32)
}
inline void TestUnpackedTypes::add_unpacked_fixed32(::google::protobuf::uint32 value) {
  unpacked_fixed32_.Add(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestUnpackedTypes.unpacked_fixed32)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
TestUnpackedTypes::unpacked_fixed32() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestUnpackedTypes.unpacked_fixed32)
  return unpacked_fixed32_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
TestUnpackedTypes::mutable_unpacked_fixed32() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestUnpackedTypes.unpacked_fixed32)
  return &unpacked_fixed32_;
}

// repeated fixed64 unpacked_fixed64 = 97 [packed = false];
inline int TestUnpackedTypes::unpacked_fixed64_size() const {
  return unpacked_fixed64_.size();
}
inline void TestUnpackedTypes::clear_unpacked_fixed64() {
  unpacked_fixed64_.Clear();
}
inline ::google::protobuf::uint64 TestUnpackedTypes::unpacked_fixed64(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestUnpackedTypes.unpacked_fixed64)
  return unpacked_fixed64_.Get(index);
}
inline void TestUnpackedTypes::set_unpacked_fixed64(int index, ::google::protobuf::uint64 value) {
  unpacked_fixed64_.Set(index, value);
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestUnpackedTypes.unpacked_fixed64)
}
inline void TestUnpackedTypes::add_unpacked_fixed64(::google::protobuf::uint64 value) {
  unpacked_fixed64_.Add(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestUnpackedTypes.unpacked_fixed64)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >&
TestUnpackedTypes::unpacked_fixed64() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestUnpackedTypes.unpacked_fixed64)
  return unpacked_fixed64_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >*
TestUnpackedTypes::mutable_unpacked_fixed64() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestUnpackedTypes.unpacked_fixed64)
  return &unpacked_fixed64_;
}

// repeated sfixed32 unpacked_sfixed32 = 98 [packed = false];
inline int TestUnpackedTypes::unpacked_sfixed32_size() const {
  return unpacked_sfixed32_.size();
}
inline void TestUnpackedTypes::clear_unpacked_sfixed32() {
  unpacked_sfixed32_.Clear();
}
inline ::google::protobuf::int32 TestUnpackedTypes::unpacked_sfixed32(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestUnpackedTypes.unpacked_sfixed32)
  return unpacked_sfixed32_.Get(index);
}
inline void TestUnpackedTypes::set_unpacked_sfixed32(int index, ::google::protobuf::int32 value) {
  unpacked_sfixed32_.Set(index, value);
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestUnpackedTypes.unpacked_sfixed32)
}
inline void TestUnpackedTypes::add_unpacked_sfixed32(::google::protobuf::int32 value) {
  unpacked_sfixed32_.Add(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestUnpackedTypes.unpacked_sfixed32)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
TestUnpackedTypes::unpacked_sfixed32() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestUnpackedTypes.unpacked_sfixed32)
  return unpacked_sfixed32_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
TestUnpackedTypes::mutable_unpacked_sfixed32() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestUnpackedTypes.unpacked_sfixed32)
  return &unpacked_sfixed32_;
}

// repeated sfixed64 unpacked_sfixed64 = 99 [packed = false];
inline int TestUnpackedTypes::unpacked_sfixed64_size() const {
  return unpacked_sfixed64_.size();
}
inline void TestUnpackedTypes::clear_unpacked_sfixed64() {
  unpacked_sfixed64_.Clear();
}
inline ::google::protobuf::int64 TestUnpackedTypes::unpacked_sfixed64(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestUnpackedTypes.unpacked_sfixed64)
  return unpacked_sfixed64_.Get(index);
}
inline void TestUnpackedTypes::set_unpacked_sfixed64(int index, ::google::protobuf::int64 value) {
  unpacked_sfixed64_.Set(index, value);
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestUnpackedTypes.unpacked_sfixed64)
}
inline void TestUnpackedTypes::add_unpacked_sfixed64(::google::protobuf::int64 value) {
  unpacked_sfixed64_.Add(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestUnpackedTypes.unpacked_sfixed64)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
TestUnpackedTypes::unpacked_sfixed64() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestUnpackedTypes.unpacked_sfixed64)
  return unpacked_sfixed64_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
TestUnpackedTypes::mutable_unpacked_sfixed64() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestUnpackedTypes.unpacked_sfixed64)
  return &unpacked_sfixed64_;
}

// repeated float unpacked_float = 100 [packed = false];
inline int TestUnpackedTypes::unpacked_float_size() const {
  return unpacked_float_.size();
}
inline void TestUnpackedTypes::clear_unpacked_float() {
  unpacked_float_.Clear();
}
inline float TestUnpackedTypes::unpacked_float(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestUnpackedTypes.unpacked_float)
  return unpacked_float_.Get(index);
}
inline void TestUnpackedTypes::set_unpacked_float(int index, float value) {
  unpacked_float_.Set(index, value);
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestUnpackedTypes.unpacked_float)
}
inline void TestUnpackedTypes::add_unpacked_float(float value) {
  unpacked_float_.Add(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestUnpackedTypes.unpacked_float)
}
inline const ::google::protobuf::RepeatedField< float >&
TestUnpackedTypes::unpacked_float() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestUnpackedTypes.unpacked_float)
  return unpacked_float_;
}
inline ::google::protobuf::RepeatedField< float >*
TestUnpackedTypes::mutable_unpacked_float() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestUnpackedTypes.unpacked_float)
  return &unpacked_float_;
}

// repeated double unpacked_double = 101 [packed = false];
inline int TestUnpackedTypes::unpacked_double_size() const {
  return unpacked_double_.size();
}
inline void TestUnpackedTypes::clear_unpacked_double() {
  unpacked_double_.Clear();
}
inline double TestUnpackedTypes::unpacked_double(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestUnpackedTypes.unpacked_double)
  return unpacked_double_.Get(index);
}
inline void TestUnpackedTypes::set_unpacked_double(int index, double value) {
  unpacked_double_.Set(index, value);
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestUnpackedTypes.unpacked_double)
}
inline void TestUnpackedTypes::add_unpacked_double(double value) {
  unpacked_double_.Add(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestUnpackedTypes.unpacked_double)
}
inline const ::google::protobuf::RepeatedField< double >&
TestUnpackedTypes::unpacked_double() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestUnpackedTypes.unpacked_double)
  return unpacked_double_;
}
inline ::google::protobuf::RepeatedField< double >*
TestUnpackedTypes::mutable_unpacked_double() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestUnpackedTypes.unpacked_double)
  return &unpacked_double_;
}

// repeated bool unpacked_bool = 102 [packed = false];
inline int TestUnpackedTypes::unpacked_bool_size() const {
  return unpacked_bool_.size();
}
inline void TestUnpackedTypes::clear_unpacked_bool() {
  unpacked_bool_.Clear();
}
inline bool TestUnpackedTypes::unpacked_bool(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestUnpackedTypes.unpacked_bool)
  return unpacked_bool_.Get(index);
}
inline void TestUnpackedTypes::set_unpacked_bool(int index, bool value) {
  unpacked_bool_.Set(index, value);
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestUnpackedTypes.unpacked_bool)
}
inline void TestUnpackedTypes::add_unpacked_bool(bool value) {
  unpacked_bool_.Add(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestUnpackedTypes.unpacked_bool)
}
inline const ::google::protobuf::RepeatedField< bool >&
TestUnpackedTypes::unpacked_bool() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestUnpackedTypes.unpacked_bool)
  return unpacked_bool_;
}
inline ::google::protobuf::RepeatedField< bool >*
TestUnpackedTypes::mutable_unpacked_bool() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestUnpackedTypes.unpacked_bool)
  return &unpacked_bool_;
}

// repeated .protobuf_unittest.ForeignEnum unpacked_enum = 103 [packed = false];
inline int TestUnpackedTypes::unpacked_enum_size() const {
  return unpacked_enum_.size();
}
inline void TestUnpackedTypes::clear_unpacked_enum() {
  unpacked_enum_.Clear();
}
inline ::protobuf_unittest::ForeignEnum TestUnpackedTypes::unpacked_enum(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestUnpackedTypes.unpacked_enum)
  return static_cast< ::protobuf_unittest::ForeignEnum >(unpacked_enum_.Get(index));
}
inline void TestUnpackedTypes::set_unpacked_enum(int index, ::protobuf_unittest::ForeignEnum value) {
  assert(::protobuf_unittest::ForeignEnum_IsValid(value));
  unpacked_enum_.Set(index, value);
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestUnpackedTypes.unpacked_enum)
}
inline void TestUnpackedTypes::add_unpacked_enum(::protobuf_unittest::ForeignEnum value) {
  assert(::protobuf_unittest::ForeignEnum_IsValid(value));
  unpacked_enum_.Add(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestUnpackedTypes.unpacked_enum)
}
inline const ::google::protobuf::RepeatedField<int>&
TestUnpackedTypes::unpacked_enum() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestUnpackedTypes.unpacked_enum)
  return unpacked_enum_;
}
inline ::google::protobuf::RepeatedField<int>*
TestUnpackedTypes::mutable_unpacked_enum() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestUnpackedTypes.unpacked_enum)
  return &unpacked_enum_;
}

// -------------------------------------------------------------------

// TestPackedExtensions

// -------------------------------------------------------------------

// TestUnpackedExtensions

// -------------------------------------------------------------------

// TestDynamicExtensions_DynamicMessageType

// optional int32 dynamic_field = 2100;
inline bool TestDynamicExtensions_DynamicMessageType::has_dynamic_field() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TestDynamicExtensions_DynamicMessageType::set_has_dynamic_field() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TestDynamicExtensions_DynamicMessageType::clear_has_dynamic_field() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TestDynamicExtensions_DynamicMessageType::clear_dynamic_field() {
  dynamic_field_ = 0;
  clear_has_dynamic_field();
}
inline ::google::protobuf::int32 TestDynamicExtensions_DynamicMessageType::dynamic_field() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestDynamicExtensions.DynamicMessageType.dynamic_field)
  return dynamic_field_;
}
inline void TestDynamicExtensions_DynamicMessageType::set_dynamic_field(::google::protobuf::int32 value) {
  set_has_dynamic_field();
  dynamic_field_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestDynamicExtensions.DynamicMessageType.dynamic_field)
}

// -------------------------------------------------------------------

// TestDynamicExtensions

// optional fixed32 scalar_extension = 2000;
inline bool TestDynamicExtensions::has_scalar_extension() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void TestDynamicExtensions::set_has_scalar_extension() {
  _has_bits_[0] |= 0x00000004u;
}
inline void TestDynamicExtensions::clear_has_scalar_extension() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void TestDynamicExtensions::clear_scalar_extension() {
  scalar_extension_ = 0u;
  clear_has_scalar_extension();
}
inline ::google::protobuf::uint32 TestDynamicExtensions::scalar_extension() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestDynamicExtensions.scalar_extension)
  return scalar_extension_;
}
inline void TestDynamicExtensions::set_scalar_extension(::google::protobuf::uint32 value) {
  set_has_scalar_extension();
  scalar_extension_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestDynamicExtensions.scalar_extension)
}

// optional .protobuf_unittest.ForeignEnum enum_extension = 2001;
inline bool TestDynamicExtensions::has_enum_extension() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void TestDynamicExtensions::set_has_enum_extension() {
  _has_bits_[0] |= 0x00000008u;
}
inline void TestDynamicExtensions::clear_has_enum_extension() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void TestDynamicExtensions::clear_enum_extension() {
  enum_extension_ = 4;
  clear_has_enum_extension();
}
inline ::protobuf_unittest::ForeignEnum TestDynamicExtensions::enum_extension() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestDynamicExtensions.enum_extension)
  return static_cast< ::protobuf_unittest::ForeignEnum >(enum_extension_);
}
inline void TestDynamicExtensions::set_enum_extension(::protobuf_unittest::ForeignEnum value) {
  assert(::protobuf_unittest::ForeignEnum_IsValid(value));
  set_has_enum_extension();
  enum_extension_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestDynamicExtensions.enum_extension)
}

// optional .protobuf_unittest.TestDynamicExtensions.DynamicEnumType dynamic_enum_extension = 2002;
inline bool TestDynamicExtensions::has_dynamic_enum_extension() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void TestDynamicExtensions::set_has_dynamic_enum_extension() {
  _has_bits_[0] |= 0x00000010u;
}
inline void TestDynamicExtensions::clear_has_dynamic_enum_extension() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void TestDynamicExtensions::clear_dynamic_enum_extension() {
  dynamic_enum_extension_ = 2200;
  clear_has_dynamic_enum_extension();
}
inline ::protobuf_unittest::TestDynamicExtensions_DynamicEnumType TestDynamicExtensions::dynamic_enum_extension() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestDynamicExtensions.dynamic_enum_extension)
  return static_cast< ::protobuf_unittest::TestDynamicExtensions_DynamicEnumType >(dynamic_enum_extension_);
}
inline void TestDynamicExtensions::set_dynamic_enum_extension(::protobuf_unittest::TestDynamicExtensions_DynamicEnumType value) {
  assert(::protobuf_unittest::TestDynamicExtensions_DynamicEnumType_IsValid(value));
  set_has_dynamic_enum_extension();
  dynamic_enum_extension_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestDynamicExtensions.dynamic_enum_extension)
}

// optional .protobuf_unittest.ForeignMessage message_extension = 2003;
inline bool TestDynamicExtensions::has_message_extension() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TestDynamicExtensions::set_has_message_extension() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TestDynamicExtensions::clear_has_message_extension() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TestDynamicExtensions::clear_message_extension() {
  if (message_extension_ != NULL) message_extension_->Clear();
  clear_has_message_extension();
}
inline const ::protobuf_unittest::ForeignMessage& TestDynamicExtensions::_internal_message_extension() const {
  return *message_extension_;
}
inline const ::protobuf_unittest::ForeignMessage& TestDynamicExtensions::message_extension() const {
  const ::protobuf_unittest::ForeignMessage* p = message_extension_;
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestDynamicExtensions.message_extension)
  return p != NULL ? *p : *reinterpret_cast<const ::protobuf_unittest::ForeignMessage*>(
      &::protobuf_unittest::_ForeignMessage_default_instance_);
}
inline ::protobuf_unittest::ForeignMessage* TestDynamicExtensions::release_message_extension() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestDynamicExtensions.message_extension)
  clear_has_message_extension();
  ::protobuf_unittest::ForeignMessage* temp = message_extension_;
  if (GetArenaNoVirtual() != NULL) {
    temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
  }
  message_extension_ = NULL;
  return temp;
}
inline ::protobuf_unittest::ForeignMessage* TestDynamicExtensions::unsafe_arena_release_message_extension() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestDynamicExtensions.message_extension)
  clear_has_message_extension();
  ::protobuf_unittest::ForeignMessage* temp = message_extension_;
  message_extension_ = NULL;
  return temp;
}
inline ::protobuf_unittest::ForeignMessage* TestDynamicExtensions::mutable_message_extension() {
  set_has_message_extension();
  if (message_extension_ == NULL) {
    auto* p = CreateMaybeMessage<::protobuf_unittest::ForeignMessage>(GetArenaNoVirtual());
    message_extension_ = p;
  }
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestDynamicExtensions.message_extension)
  return message_extension_;
}
inline void TestDynamicExtensions::set_allocated_message_extension(::protobuf_unittest::ForeignMessage* message_extension) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete message_extension_;
  }
  if (message_extension) {
    ::google::protobuf::Arena* submessage_arena =
      ::google::protobuf::Arena::GetArena(message_extension);
    if (message_arena != submessage_arena) {
      message_extension = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, message_extension, submessage_arena);
    }
    set_has_message_extension();
  } else {
    clear_has_message_extension();
  }
  message_extension_ = message_extension;
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestDynamicExtensions.message_extension)
}

// optional .protobuf_unittest.TestDynamicExtensions.DynamicMessageType dynamic_message_extension = 2004;
inline bool TestDynamicExtensions::has_dynamic_message_extension() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void TestDynamicExtensions::set_has_dynamic_message_extension() {
  _has_bits_[0] |= 0x00000002u;
}
inline void TestDynamicExtensions::clear_has_dynamic_message_extension() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void TestDynamicExtensions::clear_dynamic_message_extension() {
  if (dynamic_message_extension_ != NULL) dynamic_message_extension_->Clear();
  clear_has_dynamic_message_extension();
}
inline const ::protobuf_unittest::TestDynamicExtensions_DynamicMessageType& TestDynamicExtensions::_internal_dynamic_message_extension() const {
  return *dynamic_message_extension_;
}
inline const ::protobuf_unittest::TestDynamicExtensions_DynamicMessageType& TestDynamicExtensions::dynamic_message_extension() const {
  const ::protobuf_unittest::TestDynamicExtensions_DynamicMessageType* p = dynamic_message_extension_;
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestDynamicExtensions.dynamic_message_extension)
  return p != NULL ? *p : *reinterpret_cast<const ::protobuf_unittest::TestDynamicExtensions_DynamicMessageType*>(
      &::protobuf_unittest::_TestDynamicExtensions_DynamicMessageType_default_instance_);
}
inline ::protobuf_unittest::TestDynamicExtensions_DynamicMessageType* TestDynamicExtensions::release_dynamic_message_extension() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestDynamicExtensions.dynamic_message_extension)
  clear_has_dynamic_message_extension();
  ::protobuf_unittest::TestDynamicExtensions_DynamicMessageType* temp = dynamic_message_extension_;
  if (GetArenaNoVirtual() != NULL) {
    temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
  }
  dynamic_message_extension_ = NULL;
  return temp;
}
inline ::protobuf_unittest::TestDynamicExtensions_DynamicMessageType* TestDynamicExtensions::unsafe_arena_release_dynamic_message_extension() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestDynamicExtensions.dynamic_message_extension)
  clear_has_dynamic_message_extension();
  ::protobuf_unittest::TestDynamicExtensions_DynamicMessageType* temp = dynamic_message_extension_;
  dynamic_message_extension_ = NULL;
  return temp;
}
inline ::protobuf_unittest::TestDynamicExtensions_DynamicMessageType* TestDynamicExtensions::mutable_dynamic_message_extension() {
  set_has_dynamic_message_extension();
  if (dynamic_message_extension_ == NULL) {
    auto* p = CreateMaybeMessage<::protobuf_unittest::TestDynamicExtensions_DynamicMessageType>(GetArenaNoVirtual());
    dynamic_message_extension_ = p;
  }
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestDynamicExtensions.dynamic_message_extension)
  return dynamic_message_extension_;
}
inline void TestDynamicExtensions::set_allocated_dynamic_message_extension(::protobuf_unittest::TestDynamicExtensions_DynamicMessageType* dynamic_message_extension) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete dynamic_message_extension_;
  }
  if (dynamic_message_extension) {
    ::google::protobuf::Arena* submessage_arena =
      ::google::protobuf::Arena::GetArena(dynamic_message_extension);
    if (message_arena != submessage_arena) {
      dynamic_message_extension = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, dynamic_message_extension, submessage_arena);
    }
    set_has_dynamic_message_extension();
  } else {
    clear_has_dynamic_message_extension();
  }
  dynamic_message_extension_ = dynamic_message_extension;
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestDynamicExtensions.dynamic_message_extension)
}

// repeated string repeated_extension = 2005;
inline int TestDynamicExtensions::repeated_extension_size() const {
  return repeated_extension_.size();
}
inline void TestDynamicExtensions::clear_repeated_extension() {
  repeated_extension_.Clear();
}
inline const ::std::string& TestDynamicExtensions::repeated_extension(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestDynamicExtensions.repeated_extension)
  return repeated_extension_.Get(index);
}
inline ::std::string* TestDynamicExtensions::mutable_repeated_extension(int index) {
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestDynamicExtensions.repeated_extension)
  return repeated_extension_.Mutable(index);
}
inline void TestDynamicExtensions::set_repeated_extension(int index, const ::std::string& value) {
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestDynamicExtensions.repeated_extension)
  repeated_extension_.Mutable(index)->assign(value);
}
#if LANG_CXX11
inline void TestDynamicExtensions::set_repeated_extension(int index, ::std::string&& value) {
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestDynamicExtensions.repeated_extension)
  repeated_extension_.Mutable(index)->assign(std::move(value));
}
#endif
inline void TestDynamicExtensions::set_repeated_extension(int index, const char* value) {
  GOOGLE_DCHECK(value != NULL);
  repeated_extension_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:protobuf_unittest.TestDynamicExtensions.repeated_extension)
}
inline void TestDynamicExtensions::set_repeated_extension(int index, const char* value, size_t size) {
  repeated_extension_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:protobuf_unittest.TestDynamicExtensions.repeated_extension)
}
inline ::std::string* TestDynamicExtensions::add_repeated_extension() {
  // @@protoc_insertion_point(field_add_mutable:protobuf_unittest.TestDynamicExtensions.repeated_extension)
  return repeated_extension_.Add();
}
inline void TestDynamicExtensions::add_repeated_extension(const ::std::string& value) {
  repeated_extension_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestDynamicExtensions.repeated_extension)
}
#if LANG_CXX11
inline void TestDynamicExtensions::add_repeated_extension(::std::string&& value) {
  repeated_extension_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestDynamicExtensions.repeated_extension)
}
#endif
inline void TestDynamicExtensions::add_repeated_extension(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  repeated_extension_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:protobuf_unittest.TestDynamicExtensions.repeated_extension)
}
inline void TestDynamicExtensions::add_repeated_extension(const char* value, size_t size) {
  repeated_extension_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:protobuf_unittest.TestDynamicExtensions.repeated_extension)
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
TestDynamicExtensions::repeated_extension() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestDynamicExtensions.repeated_extension)
  return repeated_extension_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
TestDynamicExtensions::mutable_repeated_extension() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestDynamicExtensions.repeated_extension)
  return &repeated_extension_;
}

// repeated sint32 packed_extension = 2006 [packed = true];
inline int TestDynamicExtensions::packed_extension_size() const {
  return packed_extension_.size();
}
inline void TestDynamicExtensions::clear_packed_extension() {
  packed_extension_.Clear();
}
inline ::google::protobuf::int32 TestDynamicExtensions::packed_extension(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestDynamicExtensions.packed_extension)
  return packed_extension_.Get(index);
}
inline void TestDynamicExtensions::set_packed_extension(int index, ::google::protobuf::int32 value) {
  packed_extension_.Set(index, value);
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestDynamicExtensions.packed_extension)
}
inline void TestDynamicExtensions::add_packed_extension(::google::protobuf::int32 value) {
  packed_extension_.Add(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestDynamicExtensions.packed_extension)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
TestDynamicExtensions::packed_extension() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestDynamicExtensions.packed_extension)
  return packed_extension_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
TestDynamicExtensions::mutable_packed_extension() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestDynamicExtensions.packed_extension)
  return &packed_extension_;
}

// -------------------------------------------------------------------

// TestRepeatedScalarDifferentTagSizes

// repeated fixed32 repeated_fixed32 = 12;
inline int TestRepeatedScalarDifferentTagSizes::repeated_fixed32_size() const {
  return repeated_fixed32_.size();
}
inline void TestRepeatedScalarDifferentTagSizes::clear_repeated_fixed32() {
  repeated_fixed32_.Clear();
}
inline ::google::protobuf::uint32 TestRepeatedScalarDifferentTagSizes::repeated_fixed32(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestRepeatedScalarDifferentTagSizes.repeated_fixed32)
  return repeated_fixed32_.Get(index);
}
inline void TestRepeatedScalarDifferentTagSizes::set_repeated_fixed32(int index, ::google::protobuf::uint32 value) {
  repeated_fixed32_.Set(index, value);
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestRepeatedScalarDifferentTagSizes.repeated_fixed32)
}
inline void TestRepeatedScalarDifferentTagSizes::add_repeated_fixed32(::google::protobuf::uint32 value) {
  repeated_fixed32_.Add(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestRepeatedScalarDifferentTagSizes.repeated_fixed32)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
TestRepeatedScalarDifferentTagSizes::repeated_fixed32() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestRepeatedScalarDifferentTagSizes.repeated_fixed32)
  return repeated_fixed32_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
TestRepeatedScalarDifferentTagSizes::mutable_repeated_fixed32() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestRepeatedScalarDifferentTagSizes.repeated_fixed32)
  return &repeated_fixed32_;
}

// repeated int32 repeated_int32 = 13;
inline int TestRepeatedScalarDifferentTagSizes::repeated_int32_size() const {
  return repeated_int32_.size();
}
inline void TestRepeatedScalarDifferentTagSizes::clear_repeated_int32() {
  repeated_int32_.Clear();
}
inline ::google::protobuf::int32 TestRepeatedScalarDifferentTagSizes::repeated_int32(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestRepeatedScalarDifferentTagSizes.repeated_int32)
  return repeated_int32_.Get(index);
}
inline void TestRepeatedScalarDifferentTagSizes::set_repeated_int32(int index, ::google::protobuf::int32 value) {
  repeated_int32_.Set(index, value);
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestRepeatedScalarDifferentTagSizes.repeated_int32)
}
inline void TestRepeatedScalarDifferentTagSizes::add_repeated_int32(::google::protobuf::int32 value) {
  repeated_int32_.Add(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestRepeatedScalarDifferentTagSizes.repeated_int32)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
TestRepeatedScalarDifferentTagSizes::repeated_int32() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestRepeatedScalarDifferentTagSizes.repeated_int32)
  return repeated_int32_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
TestRepeatedScalarDifferentTagSizes::mutable_repeated_int32() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestRepeatedScalarDifferentTagSizes.repeated_int32)
  return &repeated_int32_;
}

// repeated fixed64 repeated_fixed64 = 2046;
inline int TestRepeatedScalarDifferentTagSizes::repeated_fixed64_size() const {
  return repeated_fixed64_.size();
}
inline void TestRepeatedScalarDifferentTagSizes::clear_repeated_fixed64() {
  repeated_fixed64_.Clear();
}
inline ::google::protobuf::uint64 TestRepeatedScalarDifferentTagSizes::repeated_fixed64(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestRepeatedScalarDifferentTagSizes.repeated_fixed64)
  return repeated_fixed64_.Get(index);
}
inline void TestRepeatedScalarDifferentTagSizes::set_repeated_fixed64(int index, ::google::protobuf::uint64 value) {
  repeated_fixed64_.Set(index, value);
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestRepeatedScalarDifferentTagSizes.repeated_fixed64)
}
inline void TestRepeatedScalarDifferentTagSizes::add_repeated_fixed64(::google::protobuf::uint64 value) {
  repeated_fixed64_.Add(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestRepeatedScalarDifferentTagSizes.repeated_fixed64)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >&
TestRepeatedScalarDifferentTagSizes::repeated_fixed64() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestRepeatedScalarDifferentTagSizes.repeated_fixed64)
  return repeated_fixed64_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >*
TestRepeatedScalarDifferentTagSizes::mutable_repeated_fixed64() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestRepeatedScalarDifferentTagSizes.repeated_fixed64)
  return &repeated_fixed64_;
}

// repeated int64 repeated_int64 = 2047;
inline int TestRepeatedScalarDifferentTagSizes::repeated_int64_size() const {
  return repeated_int64_.size();
}
inline void TestRepeatedScalarDifferentTagSizes::clear_repeated_int64() {
  repeated_int64_.Clear();
}
inline ::google::protobuf::int64 TestRepeatedScalarDifferentTagSizes::repeated_int64(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestRepeatedScalarDifferentTagSizes.repeated_int64)
  return repeated_int64_.Get(index);
}
inline void TestRepeatedScalarDifferentTagSizes::set_repeated_int64(int index, ::google::protobuf::int64 value) {
  repeated_int64_.Set(index, value);
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestRepeatedScalarDifferentTagSizes.repeated_int64)
}
inline void TestRepeatedScalarDifferentTagSizes::add_repeated_int64(::google::protobuf::int64 value) {
  repeated_int64_.Add(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestRepeatedScalarDifferentTagSizes.repeated_int64)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
TestRepeatedScalarDifferentTagSizes::repeated_int64() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestRepeatedScalarDifferentTagSizes.repeated_int64)
  return repeated_int64_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
TestRepeatedScalarDifferentTagSizes::mutable_repeated_int64() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestRepeatedScalarDifferentTagSizes.repeated_int64)
  return &repeated_int64_;
}

// repeated float repeated_float = 262142;
inline int TestRepeatedScalarDifferentTagSizes::repeated_float_size() const {
  return repeated_float_.size();
}
inline void TestRepeatedScalarDifferentTagSizes::clear_repeated_float() {
  repeated_float_.Clear();
}
inline float TestRepeatedScalarDifferentTagSizes::repeated_float(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestRepeatedScalarDifferentTagSizes.repeated_float)
  return repeated_float_.Get(index);
}
inline void TestRepeatedScalarDifferentTagSizes::set_repeated_float(int index, float value) {
  repeated_float_.Set(index, value);
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestRepeatedScalarDifferentTagSizes.repeated_float)
}
inline void TestRepeatedScalarDifferentTagSizes::add_repeated_float(float value) {
  repeated_float_.Add(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestRepeatedScalarDifferentTagSizes.repeated_float)
}
inline const ::google::protobuf::RepeatedField< float >&
TestRepeatedScalarDifferentTagSizes::repeated_float() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestRepeatedScalarDifferentTagSizes.repeated_float)
  return repeated_float_;
}
inline ::google::protobuf::RepeatedField< float >*
TestRepeatedScalarDifferentTagSizes::mutable_repeated_float() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestRepeatedScalarDifferentTagSizes.repeated_float)
  return &repeated_float_;
}

// repeated uint64 repeated_uint64 = 262143;
inline int TestRepeatedScalarDifferentTagSizes::repeated_uint64_size() const {
  return repeated_uint64_.size();
}
inline void TestRepeatedScalarDifferentTagSizes::clear_repeated_uint64() {
  repeated_uint64_.Clear();
}
inline ::google::protobuf::uint64 TestRepeatedScalarDifferentTagSizes::repeated_uint64(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestRepeatedScalarDifferentTagSizes.repeated_uint64)
  return repeated_uint64_.Get(index);
}
inline void TestRepeatedScalarDifferentTagSizes::set_repeated_uint64(int index, ::google::protobuf::uint64 value) {
  repeated_uint64_.Set(index, value);
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestRepeatedScalarDifferentTagSizes.repeated_uint64)
}
inline void TestRepeatedScalarDifferentTagSizes::add_repeated_uint64(::google::protobuf::uint64 value) {
  repeated_uint64_.Add(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestRepeatedScalarDifferentTagSizes.repeated_uint64)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >&
TestRepeatedScalarDifferentTagSizes::repeated_uint64() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestRepeatedScalarDifferentTagSizes.repeated_uint64)
  return repeated_uint64_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >*
TestRepeatedScalarDifferentTagSizes::mutable_repeated_uint64() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestRepeatedScalarDifferentTagSizes.repeated_uint64)
  return &repeated_uint64_;
}

// -------------------------------------------------------------------

// TestParsingMerge_RepeatedFieldsGenerator_Group1

// optional .protobuf_unittest.TestAllTypes field1 = 11;
inline bool TestParsingMerge_RepeatedFieldsGenerator_Group1::has_field1() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TestParsingMerge_RepeatedFieldsGenerator_Group1::set_has_field1() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TestParsingMerge_RepeatedFieldsGenerator_Group1::clear_has_field1() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TestParsingMerge_RepeatedFieldsGenerator_Group1::clear_field1() {
  if (field1_ != NULL) field1_->Clear();
  clear_has_field1();
}
inline const ::protobuf_unittest::TestAllTypes& TestParsingMerge_RepeatedFieldsGenerator_Group1::_internal_field1() const {
  return *field1_;
}
inline const ::protobuf_unittest::TestAllTypes& TestParsingMerge_RepeatedFieldsGenerator_Group1::field1() const {
  const ::protobuf_unittest::TestAllTypes* p = field1_;
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestParsingMerge.RepeatedFieldsGenerator.Group1.field1)
  return p != NULL ? *p : *reinterpret_cast<const ::protobuf_unittest::TestAllTypes*>(
      &::protobuf_unittest::_TestAllTypes_default_instance_);
}
inline ::protobuf_unittest::TestAllTypes* TestParsingMerge_RepeatedFieldsGenerator_Group1::release_field1() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestParsingMerge.RepeatedFieldsGenerator.Group1.field1)
  clear_has_field1();
  ::protobuf_unittest::TestAllTypes* temp = field1_;
  if (GetArenaNoVirtual() != NULL) {
    temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
  }
  field1_ = NULL;
  return temp;
}
inline ::protobuf_unittest::TestAllTypes* TestParsingMerge_RepeatedFieldsGenerator_Group1::unsafe_arena_release_field1() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestParsingMerge.RepeatedFieldsGenerator.Group1.field1)
  clear_has_field1();
  ::protobuf_unittest::TestAllTypes* temp = field1_;
  field1_ = NULL;
  return temp;
}
inline ::protobuf_unittest::TestAllTypes* TestParsingMerge_RepeatedFieldsGenerator_Group1::mutable_field1() {
  set_has_field1();
  if (field1_ == NULL) {
    auto* p = CreateMaybeMessage<::protobuf_unittest::TestAllTypes>(GetArenaNoVirtual());
    field1_ = p;
  }
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestParsingMerge.RepeatedFieldsGenerator.Group1.field1)
  return field1_;
}
inline void TestParsingMerge_RepeatedFieldsGenerator_Group1::set_allocated_field1(::protobuf_unittest::TestAllTypes* field1) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete field1_;
  }
  if (field1) {
    ::google::protobuf::Arena* submessage_arena =
      ::google::protobuf::Arena::GetArena(field1);
    if (message_arena != submessage_arena) {
      field1 = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, field1, submessage_arena);
    }
    set_has_field1();
  } else {
    clear_has_field1();
  }
  field1_ = field1;
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestParsingMerge.RepeatedFieldsGenerator.Group1.field1)
}

// -------------------------------------------------------------------

// TestParsingMerge_RepeatedFieldsGenerator_Group2

// optional .protobuf_unittest.TestAllTypes field1 = 21;
inline bool TestParsingMerge_RepeatedFieldsGenerator_Group2::has_field1() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TestParsingMerge_RepeatedFieldsGenerator_Group2::set_has_field1() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TestParsingMerge_RepeatedFieldsGenerator_Group2::clear_has_field1() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TestParsingMerge_RepeatedFieldsGenerator_Group2::clear_field1() {
  if (field1_ != NULL) field1_->Clear();
  clear_has_field1();
}
inline const ::protobuf_unittest::TestAllTypes& TestParsingMerge_RepeatedFieldsGenerator_Group2::_internal_field1() const {
  return *field1_;
}
inline const ::protobuf_unittest::TestAllTypes& TestParsingMerge_RepeatedFieldsGenerator_Group2::field1() const {
  const ::protobuf_unittest::TestAllTypes* p = field1_;
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestParsingMerge.RepeatedFieldsGenerator.Group2.field1)
  return p != NULL ? *p : *reinterpret_cast<const ::protobuf_unittest::TestAllTypes*>(
      &::protobuf_unittest::_TestAllTypes_default_instance_);
}
inline ::protobuf_unittest::TestAllTypes* TestParsingMerge_RepeatedFieldsGenerator_Group2::release_field1() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestParsingMerge.RepeatedFieldsGenerator.Group2.field1)
  clear_has_field1();
  ::protobuf_unittest::TestAllTypes* temp = field1_;
  if (GetArenaNoVirtual() != NULL) {
    temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
  }
  field1_ = NULL;
  return temp;
}
inline ::protobuf_unittest::TestAllTypes* TestParsingMerge_RepeatedFieldsGenerator_Group2::unsafe_arena_release_field1() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestParsingMerge.RepeatedFieldsGenerator.Group2.field1)
  clear_has_field1();
  ::protobuf_unittest::TestAllTypes* temp = field1_;
  field1_ = NULL;
  return temp;
}
inline ::protobuf_unittest::TestAllTypes* TestParsingMerge_RepeatedFieldsGenerator_Group2::mutable_field1() {
  set_has_field1();
  if (field1_ == NULL) {
    auto* p = CreateMaybeMessage<::protobuf_unittest::TestAllTypes>(GetArenaNoVirtual());
    field1_ = p;
  }
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestParsingMerge.RepeatedFieldsGenerator.Group2.field1)
  return field1_;
}
inline void TestParsingMerge_RepeatedFieldsGenerator_Group2::set_allocated_field1(::protobuf_unittest::TestAllTypes* field1) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete field1_;
  }
  if (field1) {
    ::google::protobuf::Arena* submessage_arena =
      ::google::protobuf::Arena::GetArena(field1);
    if (message_arena != submessage_arena) {
      field1 = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, field1, submessage_arena);
    }
    set_has_field1();
  } else {
    clear_has_field1();
  }
  field1_ = field1;
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestParsingMerge.RepeatedFieldsGenerator.Group2.field1)
}

// -------------------------------------------------------------------

// TestParsingMerge_RepeatedFieldsGenerator

// repeated .protobuf_unittest.TestAllTypes field1 = 1;
inline int TestParsingMerge_RepeatedFieldsGenerator::field1_size() const {
  return field1_.size();
}
inline void TestParsingMerge_RepeatedFieldsGenerator::clear_field1() {
  field1_.Clear();
}
inline ::protobuf_unittest::TestAllTypes* TestParsingMerge_RepeatedFieldsGenerator::mutable_field1(int index) {
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestParsingMerge.RepeatedFieldsGenerator.field1)
  return field1_.Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::TestAllTypes >*
TestParsingMerge_RepeatedFieldsGenerator::mutable_field1() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestParsingMerge.RepeatedFieldsGenerator.field1)
  return &field1_;
}
inline const ::protobuf_unittest::TestAllTypes& TestParsingMerge_RepeatedFieldsGenerator::field1(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestParsingMerge.RepeatedFieldsGenerator.field1)
  return field1_.Get(index);
}
inline ::protobuf_unittest::TestAllTypes* TestParsingMerge_RepeatedFieldsGenerator::add_field1() {
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestParsingMerge.RepeatedFieldsGenerator.field1)
  return field1_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::TestAllTypes >&
TestParsingMerge_RepeatedFieldsGenerator::field1() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestParsingMerge.RepeatedFieldsGenerator.field1)
  return field1_;
}

// repeated .protobuf_unittest.TestAllTypes field2 = 2;
inline int TestParsingMerge_RepeatedFieldsGenerator::field2_size() const {
  return field2_.size();
}
inline void TestParsingMerge_RepeatedFieldsGenerator::clear_field2() {
  field2_.Clear();
}
inline ::protobuf_unittest::TestAllTypes* TestParsingMerge_RepeatedFieldsGenerator::mutable_field2(int index) {
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestParsingMerge.RepeatedFieldsGenerator.field2)
  return field2_.Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::TestAllTypes >*
TestParsingMerge_RepeatedFieldsGenerator::mutable_field2() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestParsingMerge.RepeatedFieldsGenerator.field2)
  return &field2_;
}
inline const ::protobuf_unittest::TestAllTypes& TestParsingMerge_RepeatedFieldsGenerator::field2(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestParsingMerge.RepeatedFieldsGenerator.field2)
  return field2_.Get(index);
}
inline ::protobuf_unittest::TestAllTypes* TestParsingMerge_RepeatedFieldsGenerator::add_field2() {
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestParsingMerge.RepeatedFieldsGenerator.field2)
  return field2_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::TestAllTypes >&
TestParsingMerge_RepeatedFieldsGenerator::field2() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestParsingMerge.RepeatedFieldsGenerator.field2)
  return field2_;
}

// repeated .protobuf_unittest.TestAllTypes field3 = 3;
inline int TestParsingMerge_RepeatedFieldsGenerator::field3_size() const {
  return field3_.size();
}
inline void TestParsingMerge_RepeatedFieldsGenerator::clear_field3() {
  field3_.Clear();
}
inline ::protobuf_unittest::TestAllTypes* TestParsingMerge_RepeatedFieldsGenerator::mutable_field3(int index) {
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestParsingMerge.RepeatedFieldsGenerator.field3)
  return field3_.Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::TestAllTypes >*
TestParsingMerge_RepeatedFieldsGenerator::mutable_field3() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestParsingMerge.RepeatedFieldsGenerator.field3)
  return &field3_;
}
inline const ::protobuf_unittest::TestAllTypes& TestParsingMerge_RepeatedFieldsGenerator::field3(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestParsingMerge.RepeatedFieldsGenerator.field3)
  return field3_.Get(index);
}
inline ::protobuf_unittest::TestAllTypes* TestParsingMerge_RepeatedFieldsGenerator::add_field3() {
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestParsingMerge.RepeatedFieldsGenerator.field3)
  return field3_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::TestAllTypes >&
TestParsingMerge_RepeatedFieldsGenerator::field3() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestParsingMerge.RepeatedFieldsGenerator.field3)
  return field3_;
}

// repeated group Group1 = 10 { ... };
inline int TestParsingMerge_RepeatedFieldsGenerator::group1_size() const {
  return group1_.size();
}
inline void TestParsingMerge_RepeatedFieldsGenerator::clear_group1() {
  group1_.Clear();
}
inline ::protobuf_unittest::TestParsingMerge_RepeatedFieldsGenerator_Group1* TestParsingMerge_RepeatedFieldsGenerator::mutable_group1(int index) {
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestParsingMerge.RepeatedFieldsGenerator.group1)
  return group1_.Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::TestParsingMerge_RepeatedFieldsGenerator_Group1 >*
TestParsingMerge_RepeatedFieldsGenerator::mutable_group1() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestParsingMerge.RepeatedFieldsGenerator.group1)
  return &group1_;
}
inline const ::protobuf_unittest::TestParsingMerge_RepeatedFieldsGenerator_Group1& TestParsingMerge_RepeatedFieldsGenerator::group1(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestParsingMerge.RepeatedFieldsGenerator.group1)
  return group1_.Get(index);
}
inline ::protobuf_unittest::TestParsingMerge_RepeatedFieldsGenerator_Group1* TestParsingMerge_RepeatedFieldsGenerator::add_group1() {
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestParsingMerge.RepeatedFieldsGenerator.group1)
  return group1_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::TestParsingMerge_RepeatedFieldsGenerator_Group1 >&
TestParsingMerge_RepeatedFieldsGenerator::group1() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestParsingMerge.RepeatedFieldsGenerator.group1)
  return group1_;
}

// repeated group Group2 = 20 { ... };
inline int TestParsingMerge_RepeatedFieldsGenerator::group2_size() const {
  return group2_.size();
}
inline void TestParsingMerge_RepeatedFieldsGenerator::clear_group2() {
  group2_.Clear();
}
inline ::protobuf_unittest::TestParsingMerge_RepeatedFieldsGenerator_Group2* TestParsingMerge_RepeatedFieldsGenerator::mutable_group2(int index) {
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestParsingMerge.RepeatedFieldsGenerator.group2)
  return group2_.Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::TestParsingMerge_RepeatedFieldsGenerator_Group2 >*
TestParsingMerge_RepeatedFieldsGenerator::mutable_group2() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestParsingMerge.RepeatedFieldsGenerator.group2)
  return &group2_;
}
inline const ::protobuf_unittest::TestParsingMerge_RepeatedFieldsGenerator_Group2& TestParsingMerge_RepeatedFieldsGenerator::group2(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestParsingMerge.RepeatedFieldsGenerator.group2)
  return group2_.Get(index);
}
inline ::protobuf_unittest::TestParsingMerge_RepeatedFieldsGenerator_Group2* TestParsingMerge_RepeatedFieldsGenerator::add_group2() {
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestParsingMerge.RepeatedFieldsGenerator.group2)
  return group2_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::TestParsingMerge_RepeatedFieldsGenerator_Group2 >&
TestParsingMerge_RepeatedFieldsGenerator::group2() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestParsingMerge.RepeatedFieldsGenerator.group2)
  return group2_;
}

// repeated .protobuf_unittest.TestAllTypes ext1 = 1000;
inline int TestParsingMerge_RepeatedFieldsGenerator::ext1_size() const {
  return ext1_.size();
}
inline void TestParsingMerge_RepeatedFieldsGenerator::clear_ext1() {
  ext1_.Clear();
}
inline ::protobuf_unittest::TestAllTypes* TestParsingMerge_RepeatedFieldsGenerator::mutable_ext1(int index) {
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestParsingMerge.RepeatedFieldsGenerator.ext1)
  return ext1_.Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::TestAllTypes >*
TestParsingMerge_RepeatedFieldsGenerator::mutable_ext1() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestParsingMerge.RepeatedFieldsGenerator.ext1)
  return &ext1_;
}
inline const ::protobuf_unittest::TestAllTypes& TestParsingMerge_RepeatedFieldsGenerator::ext1(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestParsingMerge.RepeatedFieldsGenerator.ext1)
  return ext1_.Get(index);
}
inline ::protobuf_unittest::TestAllTypes* TestParsingMerge_RepeatedFieldsGenerator::add_ext1() {
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestParsingMerge.RepeatedFieldsGenerator.ext1)
  return ext1_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::TestAllTypes >&
TestParsingMerge_RepeatedFieldsGenerator::ext1() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestParsingMerge.RepeatedFieldsGenerator.ext1)
  return ext1_;
}

// repeated .protobuf_unittest.TestAllTypes ext2 = 1001;
inline int TestParsingMerge_RepeatedFieldsGenerator::ext2_size() const {
  return ext2_.size();
}
inline void TestParsingMerge_RepeatedFieldsGenerator::clear_ext2() {
  ext2_.Clear();
}
inline ::protobuf_unittest::TestAllTypes* TestParsingMerge_RepeatedFieldsGenerator::mutable_ext2(int index) {
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestParsingMerge.RepeatedFieldsGenerator.ext2)
  return ext2_.Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::TestAllTypes >*
TestParsingMerge_RepeatedFieldsGenerator::mutable_ext2() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestParsingMerge.RepeatedFieldsGenerator.ext2)
  return &ext2_;
}
inline const ::protobuf_unittest::TestAllTypes& TestParsingMerge_RepeatedFieldsGenerator::ext2(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestParsingMerge.RepeatedFieldsGenerator.ext2)
  return ext2_.Get(index);
}
inline ::protobuf_unittest::TestAllTypes* TestParsingMerge_RepeatedFieldsGenerator::add_ext2() {
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestParsingMerge.RepeatedFieldsGenerator.ext2)
  return ext2_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::TestAllTypes >&
TestParsingMerge_RepeatedFieldsGenerator::ext2() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestParsingMerge.RepeatedFieldsGenerator.ext2)
  return ext2_;
}

// -------------------------------------------------------------------

// TestParsingMerge_OptionalGroup

// optional .protobuf_unittest.TestAllTypes optional_group_all_types = 11;
inline bool TestParsingMerge_OptionalGroup::has_optional_group_all_types() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TestParsingMerge_OptionalGroup::set_has_optional_group_all_types() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TestParsingMerge_OptionalGroup::clear_has_optional_group_all_types() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TestParsingMerge_OptionalGroup::clear_optional_group_all_types() {
  if (optional_group_all_types_ != NULL) optional_group_all_types_->Clear();
  clear_has_optional_group_all_types();
}
inline const ::protobuf_unittest::TestAllTypes& TestParsingMerge_OptionalGroup::_internal_optional_group_all_types() const {
  return *optional_group_all_types_;
}
inline const ::protobuf_unittest::TestAllTypes& TestParsingMerge_OptionalGroup::optional_group_all_types() const {
  const ::protobuf_unittest::TestAllTypes* p = optional_group_all_types_;
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestParsingMerge.OptionalGroup.optional_group_all_types)
  return p != NULL ? *p : *reinterpret_cast<const ::protobuf_unittest::TestAllTypes*>(
      &::protobuf_unittest::_TestAllTypes_default_instance_);
}
inline ::protobuf_unittest::TestAllTypes* TestParsingMerge_OptionalGroup::release_optional_group_all_types() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestParsingMerge.OptionalGroup.optional_group_all_types)
  clear_has_optional_group_all_types();
  ::protobuf_unittest::TestAllTypes* temp = optional_group_all_types_;
  if (GetArenaNoVirtual() != NULL) {
    temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
  }
  optional_group_all_types_ = NULL;
  return temp;
}
inline ::protobuf_unittest::TestAllTypes* TestParsingMerge_OptionalGroup::unsafe_arena_release_optional_group_all_types() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestParsingMerge.OptionalGroup.optional_group_all_types)
  clear_has_optional_group_all_types();
  ::protobuf_unittest::TestAllTypes* temp = optional_group_all_types_;
  optional_group_all_types_ = NULL;
  return temp;
}
inline ::protobuf_unittest::TestAllTypes* TestParsingMerge_OptionalGroup::mutable_optional_group_all_types() {
  set_has_optional_group_all_types();
  if (optional_group_all_types_ == NULL) {
    auto* p = CreateMaybeMessage<::protobuf_unittest::TestAllTypes>(GetArenaNoVirtual());
    optional_group_all_types_ = p;
  }
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestParsingMerge.OptionalGroup.optional_group_all_types)
  return optional_group_all_types_;
}
inline void TestParsingMerge_OptionalGroup::set_allocated_optional_group_all_types(::protobuf_unittest::TestAllTypes* optional_group_all_types) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete optional_group_all_types_;
  }
  if (optional_group_all_types) {
    ::google::protobuf::Arena* submessage_arena =
      ::google::protobuf::Arena::GetArena(optional_group_all_types);
    if (message_arena != submessage_arena) {
      optional_group_all_types = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, optional_group_all_types, submessage_arena);
    }
    set_has_optional_group_all_types();
  } else {
    clear_has_optional_group_all_types();
  }
  optional_group_all_types_ = optional_group_all_types;
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestParsingMerge.OptionalGroup.optional_group_all_types)
}

// -------------------------------------------------------------------

// TestParsingMerge_RepeatedGroup

// optional .protobuf_unittest.TestAllTypes repeated_group_all_types = 21;
inline bool TestParsingMerge_RepeatedGroup::has_repeated_group_all_types() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TestParsingMerge_RepeatedGroup::set_has_repeated_group_all_types() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TestParsingMerge_RepeatedGroup::clear_has_repeated_group_all_types() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TestParsingMerge_RepeatedGroup::clear_repeated_group_all_types() {
  if (repeated_group_all_types_ != NULL) repeated_group_all_types_->Clear();
  clear_has_repeated_group_all_types();
}
inline const ::protobuf_unittest::TestAllTypes& TestParsingMerge_RepeatedGroup::_internal_repeated_group_all_types() const {
  return *repeated_group_all_types_;
}
inline const ::protobuf_unittest::TestAllTypes& TestParsingMerge_RepeatedGroup::repeated_group_all_types() const {
  const ::protobuf_unittest::TestAllTypes* p = repeated_group_all_types_;
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestParsingMerge.RepeatedGroup.repeated_group_all_types)
  return p != NULL ? *p : *reinterpret_cast<const ::protobuf_unittest::TestAllTypes*>(
      &::protobuf_unittest::_TestAllTypes_default_instance_);
}
inline ::protobuf_unittest::TestAllTypes* TestParsingMerge_RepeatedGroup::release_repeated_group_all_types() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestParsingMerge.RepeatedGroup.repeated_group_all_types)
  clear_has_repeated_group_all_types();
  ::protobuf_unittest::TestAllTypes* temp = repeated_group_all_types_;
  if (GetArenaNoVirtual() != NULL) {
    temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
  }
  repeated_group_all_types_ = NULL;
  return temp;
}
inline ::protobuf_unittest::TestAllTypes* TestParsingMerge_RepeatedGroup::unsafe_arena_release_repeated_group_all_types() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestParsingMerge.RepeatedGroup.repeated_group_all_types)
  clear_has_repeated_group_all_types();
  ::protobuf_unittest::TestAllTypes* temp = repeated_group_all_types_;
  repeated_group_all_types_ = NULL;
  return temp;
}
inline ::protobuf_unittest::TestAllTypes* TestParsingMerge_RepeatedGroup::mutable_repeated_group_all_types() {
  set_has_repeated_group_all_types();
  if (repeated_group_all_types_ == NULL) {
    auto* p = CreateMaybeMessage<::protobuf_unittest::TestAllTypes>(GetArenaNoVirtual());
    repeated_group_all_types_ = p;
  }
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestParsingMerge.RepeatedGroup.repeated_group_all_types)
  return repeated_group_all_types_;
}
inline void TestParsingMerge_RepeatedGroup::set_allocated_repeated_group_all_types(::protobuf_unittest::TestAllTypes* repeated_group_all_types) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete repeated_group_all_types_;
  }
  if (repeated_group_all_types) {
    ::google::protobuf::Arena* submessage_arena =
      ::google::protobuf::Arena::GetArena(repeated_group_all_types);
    if (message_arena != submessage_arena) {
      repeated_group_all_types = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, repeated_group_all_types, submessage_arena);
    }
    set_has_repeated_group_all_types();
  } else {
    clear_has_repeated_group_all_types();
  }
  repeated_group_all_types_ = repeated_group_all_types;
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestParsingMerge.RepeatedGroup.repeated_group_all_types)
}

// -------------------------------------------------------------------

// TestParsingMerge

// required .protobuf_unittest.TestAllTypes required_all_types = 1;
inline bool TestParsingMerge::has_required_all_types() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TestParsingMerge::set_has_required_all_types() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TestParsingMerge::clear_has_required_all_types() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TestParsingMerge::clear_required_all_types() {
  if (required_all_types_ != NULL) required_all_types_->Clear();
  clear_has_required_all_types();
}
inline const ::protobuf_unittest::TestAllTypes& TestParsingMerge::_internal_required_all_types() const {
  return *required_all_types_;
}
inline const ::protobuf_unittest::TestAllTypes& TestParsingMerge::required_all_types() const {
  const ::protobuf_unittest::TestAllTypes* p = required_all_types_;
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestParsingMerge.required_all_types)
  return p != NULL ? *p : *reinterpret_cast<const ::protobuf_unittest::TestAllTypes*>(
      &::protobuf_unittest::_TestAllTypes_default_instance_);
}
inline ::protobuf_unittest::TestAllTypes* TestParsingMerge::release_required_all_types() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestParsingMerge.required_all_types)
  clear_has_required_all_types();
  ::protobuf_unittest::TestAllTypes* temp = required_all_types_;
  if (GetArenaNoVirtual() != NULL) {
    temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
  }
  required_all_types_ = NULL;
  return temp;
}
inline ::protobuf_unittest::TestAllTypes* TestParsingMerge::unsafe_arena_release_required_all_types() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestParsingMerge.required_all_types)
  clear_has_required_all_types();
  ::protobuf_unittest::TestAllTypes* temp = required_all_types_;
  required_all_types_ = NULL;
  return temp;
}
inline ::protobuf_unittest::TestAllTypes* TestParsingMerge::mutable_required_all_types() {
  set_has_required_all_types();
  if (required_all_types_ == NULL) {
    auto* p = CreateMaybeMessage<::protobuf_unittest::TestAllTypes>(GetArenaNoVirtual());
    required_all_types_ = p;
  }
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestParsingMerge.required_all_types)
  return required_all_types_;
}
inline void TestParsingMerge::set_allocated_required_all_types(::protobuf_unittest::TestAllTypes* required_all_types) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete required_all_types_;
  }
  if (required_all_types) {
    ::google::protobuf::Arena* submessage_arena =
      ::google::protobuf::Arena::GetArena(required_all_types);
    if (message_arena != submessage_arena) {
      required_all_types = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, required_all_types, submessage_arena);
    }
    set_has_required_all_types();
  } else {
    clear_has_required_all_types();
  }
  required_all_types_ = required_all_types;
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestParsingMerge.required_all_types)
}

// optional .protobuf_unittest.TestAllTypes optional_all_types = 2;
inline bool TestParsingMerge::has_optional_all_types() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void TestParsingMerge::set_has_optional_all_types() {
  _has_bits_[0] |= 0x00000002u;
}
inline void TestParsingMerge::clear_has_optional_all_types() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void TestParsingMerge::clear_optional_all_types() {
  if (optional_all_types_ != NULL) optional_all_types_->Clear();
  clear_has_optional_all_types();
}
inline const ::protobuf_unittest::TestAllTypes& TestParsingMerge::_internal_optional_all_types() const {
  return *optional_all_types_;
}
inline const ::protobuf_unittest::TestAllTypes& TestParsingMerge::optional_all_types() const {
  const ::protobuf_unittest::TestAllTypes* p = optional_all_types_;
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestParsingMerge.optional_all_types)
  return p != NULL ? *p : *reinterpret_cast<const ::protobuf_unittest::TestAllTypes*>(
      &::protobuf_unittest::_TestAllTypes_default_instance_);
}
inline ::protobuf_unittest::TestAllTypes* TestParsingMerge::release_optional_all_types() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestParsingMerge.optional_all_types)
  clear_has_optional_all_types();
  ::protobuf_unittest::TestAllTypes* temp = optional_all_types_;
  if (GetArenaNoVirtual() != NULL) {
    temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
  }
  optional_all_types_ = NULL;
  return temp;
}
inline ::protobuf_unittest::TestAllTypes* TestParsingMerge::unsafe_arena_release_optional_all_types() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestParsingMerge.optional_all_types)
  clear_has_optional_all_types();
  ::protobuf_unittest::TestAllTypes* temp = optional_all_types_;
  optional_all_types_ = NULL;
  return temp;
}
inline ::protobuf_unittest::TestAllTypes* TestParsingMerge::mutable_optional_all_types() {
  set_has_optional_all_types();
  if (optional_all_types_ == NULL) {
    auto* p = CreateMaybeMessage<::protobuf_unittest::TestAllTypes>(GetArenaNoVirtual());
    optional_all_types_ = p;
  }
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestParsingMerge.optional_all_types)
  return optional_all_types_;
}
inline void TestParsingMerge::set_allocated_optional_all_types(::protobuf_unittest::TestAllTypes* optional_all_types) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete optional_all_types_;
  }
  if (optional_all_types) {
    ::google::protobuf::Arena* submessage_arena =
      ::google::protobuf::Arena::GetArena(optional_all_types);
    if (message_arena != submessage_arena) {
      optional_all_types = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, optional_all_types, submessage_arena);
    }
    set_has_optional_all_types();
  } else {
    clear_has_optional_all_types();
  }
  optional_all_types_ = optional_all_types;
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestParsingMerge.optional_all_types)
}

// repeated .protobuf_unittest.TestAllTypes repeated_all_types = 3;
inline int TestParsingMerge::repeated_all_types_size() const {
  return repeated_all_types_.size();
}
inline void TestParsingMerge::clear_repeated_all_types() {
  repeated_all_types_.Clear();
}
inline ::protobuf_unittest::TestAllTypes* TestParsingMerge::mutable_repeated_all_types(int index) {
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestParsingMerge.repeated_all_types)
  return repeated_all_types_.Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::TestAllTypes >*
TestParsingMerge::mutable_repeated_all_types() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestParsingMerge.repeated_all_types)
  return &repeated_all_types_;
}
inline const ::protobuf_unittest::TestAllTypes& TestParsingMerge::repeated_all_types(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestParsingMerge.repeated_all_types)
  return repeated_all_types_.Get(index);
}
inline ::protobuf_unittest::TestAllTypes* TestParsingMerge::add_repeated_all_types() {
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestParsingMerge.repeated_all_types)
  return repeated_all_types_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::TestAllTypes >&
TestParsingMerge::repeated_all_types() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestParsingMerge.repeated_all_types)
  return repeated_all_types_;
}

// optional group OptionalGroup = 10 { ... };
inline bool TestParsingMerge::has_optionalgroup() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void TestParsingMerge::set_has_optionalgroup() {
  _has_bits_[0] |= 0x00000004u;
}
inline void TestParsingMerge::clear_has_optionalgroup() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void TestParsingMerge::clear_optionalgroup() {
  if (optionalgroup_ != NULL) optionalgroup_->Clear();
  clear_has_optionalgroup();
}
inline const ::protobuf_unittest::TestParsingMerge_OptionalGroup& TestParsingMerge::_internal_optionalgroup() const {
  return *optionalgroup_;
}
inline const ::protobuf_unittest::TestParsingMerge_OptionalGroup& TestParsingMerge::optionalgroup() const {
  const ::protobuf_unittest::TestParsingMerge_OptionalGroup* p = optionalgroup_;
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestParsingMerge.optionalgroup)
  return p != NULL ? *p : *reinterpret_cast<const ::protobuf_unittest::TestParsingMerge_OptionalGroup*>(
      &::protobuf_unittest::_TestParsingMerge_OptionalGroup_default_instance_);
}
inline ::protobuf_unittest::TestParsingMerge_OptionalGroup* TestParsingMerge::release_optionalgroup() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestParsingMerge.optionalgroup)
  clear_has_optionalgroup();
  ::protobuf_unittest::TestParsingMerge_OptionalGroup* temp = optionalgroup_;
  if (GetArenaNoVirtual() != NULL) {
    temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
  }
  optionalgroup_ = NULL;
  return temp;
}
inline ::protobuf_unittest::TestParsingMerge_OptionalGroup* TestParsingMerge::unsafe_arena_release_optionalgroup() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestParsingMerge.optionalgroup)
  clear_has_optionalgroup();
  ::protobuf_unittest::TestParsingMerge_OptionalGroup* temp = optionalgroup_;
  optionalgroup_ = NULL;
  return temp;
}
inline ::protobuf_unittest::TestParsingMerge_OptionalGroup* TestParsingMerge::mutable_optionalgroup() {
  set_has_optionalgroup();
  if (optionalgroup_ == NULL) {
    auto* p = CreateMaybeMessage<::protobuf_unittest::TestParsingMerge_OptionalGroup>(GetArenaNoVirtual());
    optionalgroup_ = p;
  }
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestParsingMerge.optionalgroup)
  return optionalgroup_;
}
inline void TestParsingMerge::set_allocated_optionalgroup(::protobuf_unittest::TestParsingMerge_OptionalGroup* optionalgroup) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete optionalgroup_;
  }
  if (optionalgroup) {
    ::google::protobuf::Arena* submessage_arena =
      ::google::protobuf::Arena::GetArena(optionalgroup);
    if (message_arena != submessage_arena) {
      optionalgroup = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, optionalgroup, submessage_arena);
    }
    set_has_optionalgroup();
  } else {
    clear_has_optionalgroup();
  }
  optionalgroup_ = optionalgroup;
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestParsingMerge.optionalgroup)
}

// repeated group RepeatedGroup = 20 { ... };
inline int TestParsingMerge::repeatedgroup_size() const {
  return repeatedgroup_.size();
}
inline void TestParsingMerge::clear_repeatedgroup() {
  repeatedgroup_.Clear();
}
inline ::protobuf_unittest::TestParsingMerge_RepeatedGroup* TestParsingMerge::mutable_repeatedgroup(int index) {
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestParsingMerge.repeatedgroup)
  return repeatedgroup_.Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::TestParsingMerge_RepeatedGroup >*
TestParsingMerge::mutable_repeatedgroup() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestParsingMerge.repeatedgroup)
  return &repeatedgroup_;
}
inline const ::protobuf_unittest::TestParsingMerge_RepeatedGroup& TestParsingMerge::repeatedgroup(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestParsingMerge.repeatedgroup)
  return repeatedgroup_.Get(index);
}
inline ::protobuf_unittest::TestParsingMerge_RepeatedGroup* TestParsingMerge::add_repeatedgroup() {
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestParsingMerge.repeatedgroup)
  return repeatedgroup_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::TestParsingMerge_RepeatedGroup >&
TestParsingMerge::repeatedgroup() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestParsingMerge.repeatedgroup)
  return repeatedgroup_;
}

// -------------------------------------------------------------------

// TestCommentInjectionMessage

// optional string a = 1 [default = "*/ <- Neither should this."];
inline bool TestCommentInjectionMessage::has_a() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TestCommentInjectionMessage::set_has_a() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TestCommentInjectionMessage::clear_has_a() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TestCommentInjectionMessage::clear_a() {
  a_.ClearToDefault(&::protobuf_unittest::TestCommentInjectionMessage::_i_give_permission_to_break_this_code_default_a_.get(), GetArenaNoVirtual());
  clear_has_a();
}
inline const ::std::string& TestCommentInjectionMessage::a() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestCommentInjectionMessage.a)
  return a_.Get();
}
inline void TestCommentInjectionMessage::set_a(const ::std::string& value) {
  set_has_a();
  a_.Set(&::protobuf_unittest::TestCommentInjectionMessage::_i_give_permission_to_break_this_code_default_a_.get(), value, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestCommentInjectionMessage.a)
}
#if LANG_CXX11
inline void TestCommentInjectionMessage::set_a(::std::string&& value) {
  set_has_a();
  a_.Set(
    &::protobuf_unittest::TestCommentInjectionMessage::_i_give_permission_to_break_this_code_default_a_.get(), ::std::move(value), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_rvalue:protobuf_unittest.TestCommentInjectionMessage.a)
}
#endif
inline void TestCommentInjectionMessage::set_a(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_a();
  a_.Set(&::protobuf_unittest::TestCommentInjectionMessage::_i_give_permission_to_break_this_code_default_a_.get(), ::std::string(value),
              GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_char:protobuf_unittest.TestCommentInjectionMessage.a)
}
inline void TestCommentInjectionMessage::set_a(const char* value,
    size_t size) {
  set_has_a();
  a_.Set(&::protobuf_unittest::TestCommentInjectionMessage::_i_give_permission_to_break_this_code_default_a_.get(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_pointer:protobuf_unittest.TestCommentInjectionMessage.a)
}
inline ::std::string* TestCommentInjectionMessage::mutable_a() {
  set_has_a();
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestCommentInjectionMessage.a)
  return a_.Mutable(&::protobuf_unittest::TestCommentInjectionMessage::_i_give_permission_to_break_this_code_default_a_.get(), GetArenaNoVirtual());
}
inline ::std::string* TestCommentInjectionMessage::release_a() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestCommentInjectionMessage.a)
  if (!has_a()) {
    return NULL;
  }
  clear_has_a();
  return a_.ReleaseNonDefault(&::protobuf_unittest::TestCommentInjectionMessage::_i_give_permission_to_break_this_code_default_a_.get(), GetArenaNoVirtual());
}
inline void TestCommentInjectionMessage::set_allocated_a(::std::string* a) {
  if (a != NULL) {
    set_has_a();
  } else {
    clear_has_a();
  }
  a_.SetAllocated(&::protobuf_unittest::TestCommentInjectionMessage::_i_give_permission_to_break_this_code_default_a_.get(), a,
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestCommentInjectionMessage.a)
}
inline ::std::string* TestCommentInjectionMessage::unsafe_arena_release_a() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestCommentInjectionMessage.a)
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  clear_has_a();
  return a_.UnsafeArenaRelease(&::protobuf_unittest::TestCommentInjectionMessage::_i_give_permission_to_break_this_code_default_a_.get(),
      GetArenaNoVirtual());
}
inline void TestCommentInjectionMessage::unsafe_arena_set_allocated_a(
    ::std::string* a) {
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (a != NULL) {
    set_has_a();
  } else {
    clear_has_a();
  }
  a_.UnsafeArenaSetAllocated(&::protobuf_unittest::TestCommentInjectionMessage::_i_give_permission_to_break_this_code_default_a_.get(),
      a, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf_unittest.TestCommentInjectionMessage.a)
}

// -------------------------------------------------------------------

// FooRequest

// -------------------------------------------------------------------

// FooResponse

// -------------------------------------------------------------------

// FooClientMessage

// -------------------------------------------------------------------

// FooServerMessage

// -------------------------------------------------------------------

// BarRequest

// -------------------------------------------------------------------

// BarResponse

// -------------------------------------------------------------------

// TestJsonName

// optional int32 field_name1 = 1;
inline bool TestJsonName::has_field_name1() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TestJsonName::set_has_field_name1() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TestJsonName::clear_has_field_name1() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TestJsonName::clear_field_name1() {
  field_name1_ = 0;
  clear_has_field_name1();
}
inline ::google::protobuf::int32 TestJsonName::field_name1() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestJsonName.field_name1)
  return field_name1_;
}
inline void TestJsonName::set_field_name1(::google::protobuf::int32 value) {
  set_has_field_name1();
  field_name1_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestJsonName.field_name1)
}

// optional int32 fieldName2 = 2;
inline bool TestJsonName::has_fieldname2() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void TestJsonName::set_has_fieldname2() {
  _has_bits_[0] |= 0x00000002u;
}
inline void TestJsonName::clear_has_fieldname2() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void TestJsonName::clear_fieldname2() {
  fieldname2_ = 0;
  clear_has_fieldname2();
}
inline ::google::protobuf::int32 TestJsonName::fieldname2() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestJsonName.fieldName2)
  return fieldname2_;
}
inline void TestJsonName::set_fieldname2(::google::protobuf::int32 value) {
  set_has_fieldname2();
  fieldname2_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestJsonName.fieldName2)
}

// optional int32 FieldName3 = 3;
inline bool TestJsonName::has_fieldname3() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void TestJsonName::set_has_fieldname3() {
  _has_bits_[0] |= 0x00000004u;
}
inline void TestJsonName::clear_has_fieldname3() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void TestJsonName::clear_fieldname3() {
  fieldname3_ = 0;
  clear_has_fieldname3();
}
inline ::google::protobuf::int32 TestJsonName::fieldname3() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestJsonName.FieldName3)
  return fieldname3_;
}
inline void TestJsonName::set_fieldname3(::google::protobuf::int32 value) {
  set_has_fieldname3();
  fieldname3_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestJsonName.FieldName3)
}

// optional int32 _field_name4 = 4;
inline bool TestJsonName::has__field_name4() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void TestJsonName::set_has__field_name4() {
  _has_bits_[0] |= 0x00000008u;
}
inline void TestJsonName::clear_has__field_name4() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void TestJsonName::clear__field_name4() {
  _field_name4_ = 0;
  clear_has__field_name4();
}
inline ::google::protobuf::int32 TestJsonName::_field_name4() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestJsonName._field_name4)
  return _field_name4_;
}
inline void TestJsonName::set__field_name4(::google::protobuf::int32 value) {
  set_has__field_name4();
  _field_name4_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestJsonName._field_name4)
}

// optional int32 FIELD_NAME5 = 5;
inline bool TestJsonName::has_field_name5() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void TestJsonName::set_has_field_name5() {
  _has_bits_[0] |= 0x00000010u;
}
inline void TestJsonName::clear_has_field_name5() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void TestJsonName::clear_field_name5() {
  field_name5_ = 0;
  clear_has_field_name5();
}
inline ::google::protobuf::int32 TestJsonName::field_name5() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestJsonName.FIELD_NAME5)
  return field_name5_;
}
inline void TestJsonName::set_field_name5(::google::protobuf::int32 value) {
  set_has_field_name5();
  field_name5_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestJsonName.FIELD_NAME5)
}

// optional int32 field_name6 = 6[json_name = "@type"];
inline bool TestJsonName::has_field_name6() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void TestJsonName::set_has_field_name6() {
  _has_bits_[0] |= 0x00000020u;
}
inline void TestJsonName::clear_has_field_name6() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void TestJsonName::clear_field_name6() {
  field_name6_ = 0;
  clear_has_field_name6();
}
inline ::google::protobuf::int32 TestJsonName::field_name6() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestJsonName.field_name6)
  return field_name6_;
}
inline void TestJsonName::set_field_name6(::google::protobuf::int32 value) {
  set_has_field_name6();
  field_name6_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestJsonName.field_name6)
}

// -------------------------------------------------------------------

// TestHugeFieldNumbers_OptionalGroup

// optional int32 group_a = 536870009;
inline bool TestHugeFieldNumbers_OptionalGroup::has_group_a() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TestHugeFieldNumbers_OptionalGroup::set_has_group_a() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TestHugeFieldNumbers_OptionalGroup::clear_has_group_a() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TestHugeFieldNumbers_OptionalGroup::clear_group_a() {
  group_a_ = 0;
  clear_has_group_a();
}
inline ::google::protobuf::int32 TestHugeFieldNumbers_OptionalGroup::group_a() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestHugeFieldNumbers.OptionalGroup.group_a)
  return group_a_;
}
inline void TestHugeFieldNumbers_OptionalGroup::set_group_a(::google::protobuf::int32 value) {
  set_has_group_a();
  group_a_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestHugeFieldNumbers.OptionalGroup.group_a)
}

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// TestHugeFieldNumbers

// optional int32 optional_int32 = 536870000;
inline bool TestHugeFieldNumbers::has_optional_int32() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void TestHugeFieldNumbers::set_has_optional_int32() {
  _has_bits_[0] |= 0x00000010u;
}
inline void TestHugeFieldNumbers::clear_has_optional_int32() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void TestHugeFieldNumbers::clear_optional_int32() {
  optional_int32_ = 0;
  clear_has_optional_int32();
}
inline ::google::protobuf::int32 TestHugeFieldNumbers::optional_int32() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestHugeFieldNumbers.optional_int32)
  return optional_int32_;
}
inline void TestHugeFieldNumbers::set_optional_int32(::google::protobuf::int32 value) {
  set_has_optional_int32();
  optional_int32_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestHugeFieldNumbers.optional_int32)
}

// optional int32 fixed_32 = 536870001;
inline bool TestHugeFieldNumbers::has_fixed_32() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void TestHugeFieldNumbers::set_has_fixed_32() {
  _has_bits_[0] |= 0x00000020u;
}
inline void TestHugeFieldNumbers::clear_has_fixed_32() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void TestHugeFieldNumbers::clear_fixed_32() {
  fixed_32_ = 0;
  clear_has_fixed_32();
}
inline ::google::protobuf::int32 TestHugeFieldNumbers::fixed_32() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestHugeFieldNumbers.fixed_32)
  return fixed_32_;
}
inline void TestHugeFieldNumbers::set_fixed_32(::google::protobuf::int32 value) {
  set_has_fixed_32();
  fixed_32_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestHugeFieldNumbers.fixed_32)
}

// repeated int32 repeated_int32 = 536870002 [packed = false];
inline int TestHugeFieldNumbers::repeated_int32_size() const {
  return repeated_int32_.size();
}
inline void TestHugeFieldNumbers::clear_repeated_int32() {
  repeated_int32_.Clear();
}
inline ::google::protobuf::int32 TestHugeFieldNumbers::repeated_int32(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestHugeFieldNumbers.repeated_int32)
  return repeated_int32_.Get(index);
}
inline void TestHugeFieldNumbers::set_repeated_int32(int index, ::google::protobuf::int32 value) {
  repeated_int32_.Set(index, value);
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestHugeFieldNumbers.repeated_int32)
}
inline void TestHugeFieldNumbers::add_repeated_int32(::google::protobuf::int32 value) {
  repeated_int32_.Add(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestHugeFieldNumbers.repeated_int32)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
TestHugeFieldNumbers::repeated_int32() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestHugeFieldNumbers.repeated_int32)
  return repeated_int32_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
TestHugeFieldNumbers::mutable_repeated_int32() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestHugeFieldNumbers.repeated_int32)
  return &repeated_int32_;
}

// repeated int32 packed_int32 = 536870003 [packed = true];
inline int TestHugeFieldNumbers::packed_int32_size() const {
  return packed_int32_.size();
}
inline void TestHugeFieldNumbers::clear_packed_int32() {
  packed_int32_.Clear();
}
inline ::google::protobuf::int32 TestHugeFieldNumbers::packed_int32(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestHugeFieldNumbers.packed_int32)
  return packed_int32_.Get(index);
}
inline void TestHugeFieldNumbers::set_packed_int32(int index, ::google::protobuf::int32 value) {
  packed_int32_.Set(index, value);
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestHugeFieldNumbers.packed_int32)
}
inline void TestHugeFieldNumbers::add_packed_int32(::google::protobuf::int32 value) {
  packed_int32_.Add(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestHugeFieldNumbers.packed_int32)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
TestHugeFieldNumbers::packed_int32() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestHugeFieldNumbers.packed_int32)
  return packed_int32_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
TestHugeFieldNumbers::mutable_packed_int32() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestHugeFieldNumbers.packed_int32)
  return &packed_int32_;
}

// optional .protobuf_unittest.ForeignEnum optional_enum = 536870004;
inline bool TestHugeFieldNumbers::has_optional_enum() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void TestHugeFieldNumbers::set_has_optional_enum() {
  _has_bits_[0] |= 0x00000040u;
}
inline void TestHugeFieldNumbers::clear_has_optional_enum() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void TestHugeFieldNumbers::clear_optional_enum() {
  optional_enum_ = 4;
  clear_has_optional_enum();
}
inline ::protobuf_unittest::ForeignEnum TestHugeFieldNumbers::optional_enum() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestHugeFieldNumbers.optional_enum)
  return static_cast< ::protobuf_unittest::ForeignEnum >(optional_enum_);
}
inline void TestHugeFieldNumbers::set_optional_enum(::protobuf_unittest::ForeignEnum value) {
  assert(::protobuf_unittest::ForeignEnum_IsValid(value));
  set_has_optional_enum();
  optional_enum_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestHugeFieldNumbers.optional_enum)
}

// optional string optional_string = 536870005;
inline bool TestHugeFieldNumbers::has_optional_string() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TestHugeFieldNumbers::set_has_optional_string() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TestHugeFieldNumbers::clear_has_optional_string() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TestHugeFieldNumbers::clear_optional_string() {
  optional_string_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
  clear_has_optional_string();
}
inline const ::std::string& TestHugeFieldNumbers::optional_string() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestHugeFieldNumbers.optional_string)
  return optional_string_.Get();
}
inline void TestHugeFieldNumbers::set_optional_string(const ::std::string& value) {
  set_has_optional_string();
  optional_string_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestHugeFieldNumbers.optional_string)
}
#if LANG_CXX11
inline void TestHugeFieldNumbers::set_optional_string(::std::string&& value) {
  set_has_optional_string();
  optional_string_.Set(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_rvalue:protobuf_unittest.TestHugeFieldNumbers.optional_string)
}
#endif
inline void TestHugeFieldNumbers::set_optional_string(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_optional_string();
  optional_string_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_char:protobuf_unittest.TestHugeFieldNumbers.optional_string)
}
inline void TestHugeFieldNumbers::set_optional_string(const char* value,
    size_t size) {
  set_has_optional_string();
  optional_string_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_pointer:protobuf_unittest.TestHugeFieldNumbers.optional_string)
}
inline ::std::string* TestHugeFieldNumbers::mutable_optional_string() {
  set_has_optional_string();
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestHugeFieldNumbers.optional_string)
  return optional_string_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline ::std::string* TestHugeFieldNumbers::release_optional_string() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestHugeFieldNumbers.optional_string)
  if (!has_optional_string()) {
    return NULL;
  }
  clear_has_optional_string();
  return optional_string_.ReleaseNonDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline void TestHugeFieldNumbers::set_allocated_optional_string(::std::string* optional_string) {
  if (optional_string != NULL) {
    set_has_optional_string();
  } else {
    clear_has_optional_string();
  }
  optional_string_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), optional_string,
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestHugeFieldNumbers.optional_string)
}
inline ::std::string* TestHugeFieldNumbers::unsafe_arena_release_optional_string() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestHugeFieldNumbers.optional_string)
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  clear_has_optional_string();
  return optional_string_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      GetArenaNoVirtual());
}
inline void TestHugeFieldNumbers::unsafe_arena_set_allocated_optional_string(
    ::std::string* optional_string) {
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (optional_string != NULL) {
    set_has_optional_string();
  } else {
    clear_has_optional_string();
  }
  optional_string_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      optional_string, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf_unittest.TestHugeFieldNumbers.optional_string)
}

// optional bytes optional_bytes = 536870006;
inline bool TestHugeFieldNumbers::has_optional_bytes() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void TestHugeFieldNumbers::set_has_optional_bytes() {
  _has_bits_[0] |= 0x00000002u;
}
inline void TestHugeFieldNumbers::clear_has_optional_bytes() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void TestHugeFieldNumbers::clear_optional_bytes() {
  optional_bytes_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
  clear_has_optional_bytes();
}
inline const ::std::string& TestHugeFieldNumbers::optional_bytes() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestHugeFieldNumbers.optional_bytes)
  return optional_bytes_.Get();
}
inline void TestHugeFieldNumbers::set_optional_bytes(const ::std::string& value) {
  set_has_optional_bytes();
  optional_bytes_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestHugeFieldNumbers.optional_bytes)
}
#if LANG_CXX11
inline void TestHugeFieldNumbers::set_optional_bytes(::std::string&& value) {
  set_has_optional_bytes();
  optional_bytes_.Set(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_rvalue:protobuf_unittest.TestHugeFieldNumbers.optional_bytes)
}
#endif
inline void TestHugeFieldNumbers::set_optional_bytes(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_optional_bytes();
  optional_bytes_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_char:protobuf_unittest.TestHugeFieldNumbers.optional_bytes)
}
inline void TestHugeFieldNumbers::set_optional_bytes(const void* value,
    size_t size) {
  set_has_optional_bytes();
  optional_bytes_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_pointer:protobuf_unittest.TestHugeFieldNumbers.optional_bytes)
}
inline ::std::string* TestHugeFieldNumbers::mutable_optional_bytes() {
  set_has_optional_bytes();
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestHugeFieldNumbers.optional_bytes)
  return optional_bytes_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline ::std::string* TestHugeFieldNumbers::release_optional_bytes() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestHugeFieldNumbers.optional_bytes)
  if (!has_optional_bytes()) {
    return NULL;
  }
  clear_has_optional_bytes();
  return optional_bytes_.ReleaseNonDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
}
inline void TestHugeFieldNumbers::set_allocated_optional_bytes(::std::string* optional_bytes) {
  if (optional_bytes != NULL) {
    set_has_optional_bytes();
  } else {
    clear_has_optional_bytes();
  }
  optional_bytes_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), optional_bytes,
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestHugeFieldNumbers.optional_bytes)
}
inline ::std::string* TestHugeFieldNumbers::unsafe_arena_release_optional_bytes() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestHugeFieldNumbers.optional_bytes)
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  clear_has_optional_bytes();
  return optional_bytes_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      GetArenaNoVirtual());
}
inline void TestHugeFieldNumbers::unsafe_arena_set_allocated_optional_bytes(
    ::std::string* optional_bytes) {
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (optional_bytes != NULL) {
    set_has_optional_bytes();
  } else {
    clear_has_optional_bytes();
  }
  optional_bytes_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      optional_bytes, GetArenaNoVirtual());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf_unittest.TestHugeFieldNumbers.optional_bytes)
}

// optional .protobuf_unittest.ForeignMessage optional_message = 536870007;
inline bool TestHugeFieldNumbers::has_optional_message() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void TestHugeFieldNumbers::set_has_optional_message() {
  _has_bits_[0] |= 0x00000004u;
}
inline void TestHugeFieldNumbers::clear_has_optional_message() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void TestHugeFieldNumbers::clear_optional_message() {
  if (optional_message_ != NULL) optional_message_->Clear();
  clear_has_optional_message();
}
inline const ::protobuf_unittest::ForeignMessage& TestHugeFieldNumbers::_internal_optional_message() const {
  return *optional_message_;
}
inline const ::protobuf_unittest::ForeignMessage& TestHugeFieldNumbers::optional_message() const {
  const ::protobuf_unittest::ForeignMessage* p = optional_message_;
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestHugeFieldNumbers.optional_message)
  return p != NULL ? *p : *reinterpret_cast<const ::protobuf_unittest::ForeignMessage*>(
      &::protobuf_unittest::_ForeignMessage_default_instance_);
}
inline ::protobuf_unittest::ForeignMessage* TestHugeFieldNumbers::release_optional_message() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestHugeFieldNumbers.optional_message)
  clear_has_optional_message();
  ::protobuf_unittest::ForeignMessage* temp = optional_message_;
  if (GetArenaNoVirtual() != NULL) {
    temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
  }
  optional_message_ = NULL;
  return temp;
}
inline ::protobuf_unittest::ForeignMessage* TestHugeFieldNumbers::unsafe_arena_release_optional_message() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestHugeFieldNumbers.optional_message)
  clear_has_optional_message();
  ::protobuf_unittest::ForeignMessage* temp = optional_message_;
  optional_message_ = NULL;
  return temp;
}
inline ::protobuf_unittest::ForeignMessage* TestHugeFieldNumbers::mutable_optional_message() {
  set_has_optional_message();
  if (optional_message_ == NULL) {
    auto* p = CreateMaybeMessage<::protobuf_unittest::ForeignMessage>(GetArenaNoVirtual());
    optional_message_ = p;
  }
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestHugeFieldNumbers.optional_message)
  return optional_message_;
}
inline void TestHugeFieldNumbers::set_allocated_optional_message(::protobuf_unittest::ForeignMessage* optional_message) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete optional_message_;
  }
  if (optional_message) {
    ::google::protobuf::Arena* submessage_arena =
      ::google::protobuf::Arena::GetArena(optional_message);
    if (message_arena != submessage_arena) {
      optional_message = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, optional_message, submessage_arena);
    }
    set_has_optional_message();
  } else {
    clear_has_optional_message();
  }
  optional_message_ = optional_message;
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestHugeFieldNumbers.optional_message)
}

// optional group OptionalGroup = 536870008 { ... };
inline bool TestHugeFieldNumbers::has_optionalgroup() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void TestHugeFieldNumbers::set_has_optionalgroup() {
  _has_bits_[0] |= 0x00000008u;
}
inline void TestHugeFieldNumbers::clear_has_optionalgroup() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void TestHugeFieldNumbers::clear_optionalgroup() {
  if (optionalgroup_ != NULL) optionalgroup_->Clear();
  clear_has_optionalgroup();
}
inline const ::protobuf_unittest::TestHugeFieldNumbers_OptionalGroup& TestHugeFieldNumbers::_internal_optionalgroup() const {
  return *optionalgroup_;
}
inline const ::protobuf_unittest::TestHugeFieldNumbers_OptionalGroup& TestHugeFieldNumbers::optionalgroup() const {
  const ::protobuf_unittest::TestHugeFieldNumbers_OptionalGroup* p = optionalgroup_;
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestHugeFieldNumbers.optionalgroup)
  return p != NULL ? *p : *reinterpret_cast<const ::protobuf_unittest::TestHugeFieldNumbers_OptionalGroup*>(
      &::protobuf_unittest::_TestHugeFieldNumbers_OptionalGroup_default_instance_);
}
inline ::protobuf_unittest::TestHugeFieldNumbers_OptionalGroup* TestHugeFieldNumbers::release_optionalgroup() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestHugeFieldNumbers.optionalgroup)
  clear_has_optionalgroup();
  ::protobuf_unittest::TestHugeFieldNumbers_OptionalGroup* temp = optionalgroup_;
  if (GetArenaNoVirtual() != NULL) {
    temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
  }
  optionalgroup_ = NULL;
  return temp;
}
inline ::protobuf_unittest::TestHugeFieldNumbers_OptionalGroup* TestHugeFieldNumbers::unsafe_arena_release_optionalgroup() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestHugeFieldNumbers.optionalgroup)
  clear_has_optionalgroup();
  ::protobuf_unittest::TestHugeFieldNumbers_OptionalGroup* temp = optionalgroup_;
  optionalgroup_ = NULL;
  return temp;
}
inline ::protobuf_unittest::TestHugeFieldNumbers_OptionalGroup* TestHugeFieldNumbers::mutable_optionalgroup() {
  set_has_optionalgroup();
  if (optionalgroup_ == NULL) {
    auto* p = CreateMaybeMessage<::protobuf_unittest::TestHugeFieldNumbers_OptionalGroup>(GetArenaNoVirtual());
    optionalgroup_ = p;
  }
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestHugeFieldNumbers.optionalgroup)
  return optionalgroup_;
}
inline void TestHugeFieldNumbers::set_allocated_optionalgroup(::protobuf_unittest::TestHugeFieldNumbers_OptionalGroup* optionalgroup) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete optionalgroup_;
  }
  if (optionalgroup) {
    ::google::protobuf::Arena* submessage_arena =
      ::google::protobuf::Arena::GetArena(optionalgroup);
    if (message_arena != submessage_arena) {
      optionalgroup = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, optionalgroup, submessage_arena);
    }
    set_has_optionalgroup();
  } else {
    clear_has_optionalgroup();
  }
  optionalgroup_ = optionalgroup;
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestHugeFieldNumbers.optionalgroup)
}

// map<string, string> string_string_map = 536870010;
inline int TestHugeFieldNumbers::string_string_map_size() const {
  return string_string_map_.size();
}
inline void TestHugeFieldNumbers::clear_string_string_map() {
  string_string_map_.Clear();
}
inline const ::google::protobuf::Map< ::std::string, ::std::string >&
TestHugeFieldNumbers::string_string_map() const {
  // @@protoc_insertion_point(field_map:protobuf_unittest.TestHugeFieldNumbers.string_string_map)
  return string_string_map_.GetMap();
}
inline ::google::protobuf::Map< ::std::string, ::std::string >*
TestHugeFieldNumbers::mutable_string_string_map() {
  // @@protoc_insertion_point(field_mutable_map:protobuf_unittest.TestHugeFieldNumbers.string_string_map)
  return string_string_map_.MutableMap();
}

// optional uint32 oneof_uint32 = 536870011;
inline bool TestHugeFieldNumbers::has_oneof_uint32() const {
  return oneof_field_case() == kOneofUint32;
}
inline void TestHugeFieldNumbers::set_has_oneof_uint32() {
  _oneof_case_[0] = kOneofUint32;
}
inline void TestHugeFieldNumbers::clear_oneof_uint32() {
  if (has_oneof_uint32()) {
    oneof_field_.oneof_uint32_ = 0u;
    clear_has_oneof_field();
  }
}
inline ::google::protobuf::uint32 TestHugeFieldNumbers::oneof_uint32() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestHugeFieldNumbers.oneof_uint32)
  if (has_oneof_uint32()) {
    return oneof_field_.oneof_uint32_;
  }
  return 0u;
}
inline void TestHugeFieldNumbers::set_oneof_uint32(::google::protobuf::uint32 value) {
  if (!has_oneof_uint32()) {
    clear_oneof_field();
    set_has_oneof_uint32();
  }
  oneof_field_.oneof_uint32_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestHugeFieldNumbers.oneof_uint32)
}

// optional .protobuf_unittest.TestAllTypes oneof_test_all_types = 536870012;
inline bool TestHugeFieldNumbers::has_oneof_test_all_types() const {
  return oneof_field_case() == kOneofTestAllTypes;
}
inline void TestHugeFieldNumbers::set_has_oneof_test_all_types() {
  _oneof_case_[0] = kOneofTestAllTypes;
}
inline void TestHugeFieldNumbers::clear_oneof_test_all_types() {
  if (has_oneof_test_all_types()) {
    if (GetArenaNoVirtual() == NULL) {
      delete oneof_field_.oneof_test_all_types_;
    }
    clear_has_oneof_field();
  }
}
inline const ::protobuf_unittest::TestAllTypes& TestHugeFieldNumbers::_internal_oneof_test_all_types() const {
  return *oneof_field_.oneof_test_all_types_;
}
inline ::protobuf_unittest::TestAllTypes* TestHugeFieldNumbers::release_oneof_test_all_types() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestHugeFieldNumbers.oneof_test_all_types)
  if (has_oneof_test_all_types()) {
    clear_has_oneof_field();
      ::protobuf_unittest::TestAllTypes* temp = oneof_field_.oneof_test_all_types_;
    if (GetArenaNoVirtual() != NULL) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    oneof_field_.oneof_test_all_types_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::protobuf_unittest::TestAllTypes& TestHugeFieldNumbers::oneof_test_all_types() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestHugeFieldNumbers.oneof_test_all_types)
  return has_oneof_test_all_types()
      ? *oneof_field_.oneof_test_all_types_
      : *reinterpret_cast< ::protobuf_unittest::TestAllTypes*>(&::protobuf_unittest::_TestAllTypes_default_instance_);
}
inline ::protobuf_unittest::TestAllTypes* TestHugeFieldNumbers::unsafe_arena_release_oneof_test_all_types() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestHugeFieldNumbers.oneof_test_all_types)
  if (has_oneof_test_all_types()) {
    clear_has_oneof_field();
    ::protobuf_unittest::TestAllTypes* temp = oneof_field_.oneof_test_all_types_;
    oneof_field_.oneof_test_all_types_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline void TestHugeFieldNumbers::unsafe_arena_set_allocated_oneof_test_all_types(::protobuf_unittest::TestAllTypes* oneof_test_all_types) {
  clear_oneof_field();
  if (oneof_test_all_types) {
    set_has_oneof_test_all_types();
    oneof_field_.oneof_test_all_types_ = oneof_test_all_types;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf_unittest.TestHugeFieldNumbers.oneof_test_all_types)
}
inline ::protobuf_unittest::TestAllTypes* TestHugeFieldNumbers::mutable_oneof_test_all_types() {
  if (!has_oneof_test_all_types()) {
    clear_oneof_field();
    set_has_oneof_test_all_types();
    oneof_field_.oneof_test_all_types_ = CreateMaybeMessage< ::protobuf_unittest::TestAllTypes >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestHugeFieldNumbers.oneof_test_all_types)
  return oneof_field_.oneof_test_all_types_;
}

// optional string oneof_string = 536870013;
inline bool TestHugeFieldNumbers::has_oneof_string() const {
  return oneof_field_case() == kOneofString;
}
inline void TestHugeFieldNumbers::set_has_oneof_string() {
  _oneof_case_[0] = kOneofString;
}
inline void TestHugeFieldNumbers::clear_oneof_string() {
  if (has_oneof_string()) {
    oneof_field_.oneof_string_.Destroy(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
        GetArenaNoVirtual());
    clear_has_oneof_field();
  }
}
inline const ::std::string& TestHugeFieldNumbers::oneof_string() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestHugeFieldNumbers.oneof_string)
  if (has_oneof_string()) {
    return oneof_field_.oneof_string_.Get();
  }
  return *&::google::protobuf::internal::GetEmptyStringAlreadyInited();
}
inline void TestHugeFieldNumbers::set_oneof_string(const ::std::string& value) {
  if (!has_oneof_string()) {
    clear_oneof_field();
    set_has_oneof_string();
    oneof_field_.oneof_string_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  oneof_field_.oneof_string_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value,
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestHugeFieldNumbers.oneof_string)
}
#if LANG_CXX11
inline void TestHugeFieldNumbers::set_oneof_string(::std::string&& value) {
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestHugeFieldNumbers.oneof_string)
  if (!has_oneof_string()) {
    clear_oneof_field();
    set_has_oneof_string();
    oneof_field_.oneof_string_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  oneof_field_.oneof_string_.Set(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_rvalue:protobuf_unittest.TestHugeFieldNumbers.oneof_string)
}
#endif
inline void TestHugeFieldNumbers::set_oneof_string(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  if (!has_oneof_string()) {
    clear_oneof_field();
    set_has_oneof_string();
    oneof_field_.oneof_string_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  oneof_field_.oneof_string_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(value), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_char:protobuf_unittest.TestHugeFieldNumbers.oneof_string)
}
inline void TestHugeFieldNumbers::set_oneof_string(const char* value,
                             size_t size) {
  if (!has_oneof_string()) {
    clear_oneof_field();
    set_has_oneof_string();
    oneof_field_.oneof_string_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  oneof_field_.oneof_string_.Set(
      &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size),
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_pointer:protobuf_unittest.TestHugeFieldNumbers.oneof_string)
}
inline ::std::string* TestHugeFieldNumbers::mutable_oneof_string() {
  if (!has_oneof_string()) {
    clear_oneof_field();
    set_has_oneof_string();
    oneof_field_.oneof_string_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  return oneof_field_.oneof_string_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestHugeFieldNumbers.oneof_string)
}
inline ::std::string* TestHugeFieldNumbers::release_oneof_string() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestHugeFieldNumbers.oneof_string)
  if (has_oneof_string()) {
    clear_has_oneof_field();
    return oneof_field_.oneof_string_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
        GetArenaNoVirtual());
  } else {
    return NULL;
  }
}
inline void TestHugeFieldNumbers::set_allocated_oneof_string(::std::string* oneof_string) {
  if (!has_oneof_string()) {
    oneof_field_.oneof_string_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  clear_oneof_field();
  if (oneof_string != NULL) {
    set_has_oneof_string();
    oneof_field_.oneof_string_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), oneof_string,
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestHugeFieldNumbers.oneof_string)
}
inline ::std::string* TestHugeFieldNumbers::unsafe_arena_release_oneof_string() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestHugeFieldNumbers.oneof_string)
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (has_oneof_string()) {
    clear_has_oneof_field();
    return oneof_field_.oneof_string_.UnsafeArenaRelease(
        &::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
  } else {
    return NULL;
  }
}
inline void TestHugeFieldNumbers::unsafe_arena_set_allocated_oneof_string(::std::string* oneof_string) {
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (!has_oneof_string()) {
    oneof_field_.oneof_string_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  clear_oneof_field();
  if (oneof_string) {
    set_has_oneof_string();
    oneof_field_.oneof_string_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), oneof_string, GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf_unittest.TestHugeFieldNumbers.oneof_string)
}

// optional bytes oneof_bytes = 536870014;
inline bool TestHugeFieldNumbers::has_oneof_bytes() const {
  return oneof_field_case() == kOneofBytes;
}
inline void TestHugeFieldNumbers::set_has_oneof_bytes() {
  _oneof_case_[0] = kOneofBytes;
}
inline void TestHugeFieldNumbers::clear_oneof_bytes() {
  if (has_oneof_bytes()) {
    oneof_field_.oneof_bytes_.Destroy(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
        GetArenaNoVirtual());
    clear_has_oneof_field();
  }
}
inline const ::std::string& TestHugeFieldNumbers::oneof_bytes() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestHugeFieldNumbers.oneof_bytes)
  if (has_oneof_bytes()) {
    return oneof_field_.oneof_bytes_.Get();
  }
  return *&::google::protobuf::internal::GetEmptyStringAlreadyInited();
}
inline void TestHugeFieldNumbers::set_oneof_bytes(const ::std::string& value) {
  if (!has_oneof_bytes()) {
    clear_oneof_field();
    set_has_oneof_bytes();
    oneof_field_.oneof_bytes_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  oneof_field_.oneof_bytes_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value,
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestHugeFieldNumbers.oneof_bytes)
}
#if LANG_CXX11
inline void TestHugeFieldNumbers::set_oneof_bytes(::std::string&& value) {
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestHugeFieldNumbers.oneof_bytes)
  if (!has_oneof_bytes()) {
    clear_oneof_field();
    set_has_oneof_bytes();
    oneof_field_.oneof_bytes_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  oneof_field_.oneof_bytes_.Set(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_rvalue:protobuf_unittest.TestHugeFieldNumbers.oneof_bytes)
}
#endif
inline void TestHugeFieldNumbers::set_oneof_bytes(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  if (!has_oneof_bytes()) {
    clear_oneof_field();
    set_has_oneof_bytes();
    oneof_field_.oneof_bytes_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  oneof_field_.oneof_bytes_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(value), GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_char:protobuf_unittest.TestHugeFieldNumbers.oneof_bytes)
}
inline void TestHugeFieldNumbers::set_oneof_bytes(const void* value,
                             size_t size) {
  if (!has_oneof_bytes()) {
    clear_oneof_field();
    set_has_oneof_bytes();
    oneof_field_.oneof_bytes_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  oneof_field_.oneof_bytes_.Set(
      &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size),
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_set_pointer:protobuf_unittest.TestHugeFieldNumbers.oneof_bytes)
}
inline ::std::string* TestHugeFieldNumbers::mutable_oneof_bytes() {
  if (!has_oneof_bytes()) {
    clear_oneof_field();
    set_has_oneof_bytes();
    oneof_field_.oneof_bytes_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  return oneof_field_.oneof_bytes_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      GetArenaNoVirtual());
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestHugeFieldNumbers.oneof_bytes)
}
inline ::std::string* TestHugeFieldNumbers::release_oneof_bytes() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestHugeFieldNumbers.oneof_bytes)
  if (has_oneof_bytes()) {
    clear_has_oneof_field();
    return oneof_field_.oneof_bytes_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
        GetArenaNoVirtual());
  } else {
    return NULL;
  }
}
inline void TestHugeFieldNumbers::set_allocated_oneof_bytes(::std::string* oneof_bytes) {
  if (!has_oneof_bytes()) {
    oneof_field_.oneof_bytes_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  clear_oneof_field();
  if (oneof_bytes != NULL) {
    set_has_oneof_bytes();
    oneof_field_.oneof_bytes_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), oneof_bytes,
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestHugeFieldNumbers.oneof_bytes)
}
inline ::std::string* TestHugeFieldNumbers::unsafe_arena_release_oneof_bytes() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf_unittest.TestHugeFieldNumbers.oneof_bytes)
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (has_oneof_bytes()) {
    clear_has_oneof_field();
    return oneof_field_.oneof_bytes_.UnsafeArenaRelease(
        &::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
  } else {
    return NULL;
  }
}
inline void TestHugeFieldNumbers::unsafe_arena_set_allocated_oneof_bytes(::std::string* oneof_bytes) {
  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
  if (!has_oneof_bytes()) {
    oneof_field_.oneof_bytes_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  clear_oneof_field();
  if (oneof_bytes) {
    set_has_oneof_bytes();
    oneof_field_.oneof_bytes_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), oneof_bytes, GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf_unittest.TestHugeFieldNumbers.oneof_bytes)
}

inline bool TestHugeFieldNumbers::has_oneof_field() const {
  return oneof_field_case() != ONEOF_FIELD_NOT_SET;
}
inline void TestHugeFieldNumbers::clear_has_oneof_field() {
  _oneof_case_[0] = ONEOF_FIELD_NOT_SET;
}
inline TestHugeFieldNumbers::OneofFieldCase TestHugeFieldNumbers::oneof_field_case() const {
  return TestHugeFieldNumbers::OneofFieldCase(_oneof_case_[0]);
}
// -------------------------------------------------------------------

// TestExtensionInsideTable

// optional int32 field1 = 1;
inline bool TestExtensionInsideTable::has_field1() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TestExtensionInsideTable::set_has_field1() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TestExtensionInsideTable::clear_has_field1() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TestExtensionInsideTable::clear_field1() {
  field1_ = 0;
  clear_has_field1();
}
inline ::google::protobuf::int32 TestExtensionInsideTable::field1() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestExtensionInsideTable.field1)
  return field1_;
}
inline void TestExtensionInsideTable::set_field1(::google::protobuf::int32 value) {
  set_has_field1();
  field1_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestExtensionInsideTable.field1)
}

// optional int32 field2 = 2;
inline bool TestExtensionInsideTable::has_field2() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void TestExtensionInsideTable::set_has_field2() {
  _has_bits_[0] |= 0x00000002u;
}
inline void TestExtensionInsideTable::clear_has_field2() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void TestExtensionInsideTable::clear_field2() {
  field2_ = 0;
  clear_has_field2();
}
inline ::google::protobuf::int32 TestExtensionInsideTable::field2() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestExtensionInsideTable.field2)
  return field2_;
}
inline void TestExtensionInsideTable::set_field2(::google::protobuf::int32 value) {
  set_has_field2();
  field2_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestExtensionInsideTable.field2)
}

// optional int32 field3 = 3;
inline bool TestExtensionInsideTable::has_field3() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void TestExtensionInsideTable::set_has_field3() {
  _has_bits_[0] |= 0x00000004u;
}
inline void TestExtensionInsideTable::clear_has_field3() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void TestExtensionInsideTable::clear_field3() {
  field3_ = 0;
  clear_has_field3();
}
inline ::google::protobuf::int32 TestExtensionInsideTable::field3() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestExtensionInsideTable.field3)
  return field3_;
}
inline void TestExtensionInsideTable::set_field3(::google::protobuf::int32 value) {
  set_has_field3();
  field3_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestExtensionInsideTable.field3)
}

// optional int32 field4 = 4;
inline bool TestExtensionInsideTable::has_field4() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void TestExtensionInsideTable::set_has_field4() {
  _has_bits_[0] |= 0x00000008u;
}
inline void TestExtensionInsideTable::clear_has_field4() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void TestExtensionInsideTable::clear_field4() {
  field4_ = 0;
  clear_has_field4();
}
inline ::google::protobuf::int32 TestExtensionInsideTable::field4() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestExtensionInsideTable.field4)
  return field4_;
}
inline void TestExtensionInsideTable::set_field4(::google::protobuf::int32 value) {
  set_has_field4();
  field4_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestExtensionInsideTable.field4)
}

// optional int32 field6 = 6;
inline bool TestExtensionInsideTable::has_field6() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void TestExtensionInsideTable::set_has_field6() {
  _has_bits_[0] |= 0x00000010u;
}
inline void TestExtensionInsideTable::clear_has_field6() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void TestExtensionInsideTable::clear_field6() {
  field6_ = 0;
  clear_has_field6();
}
inline ::google::protobuf::int32 TestExtensionInsideTable::field6() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestExtensionInsideTable.field6)
  return field6_;
}
inline void TestExtensionInsideTable::set_field6(::google::protobuf::int32 value) {
  set_has_field6();
  field6_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestExtensionInsideTable.field6)
}

// optional int32 field7 = 7;
inline bool TestExtensionInsideTable::has_field7() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void TestExtensionInsideTable::set_has_field7() {
  _has_bits_[0] |= 0x00000020u;
}
inline void TestExtensionInsideTable::clear_has_field7() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void TestExtensionInsideTable::clear_field7() {
  field7_ = 0;
  clear_has_field7();
}
inline ::google::protobuf::int32 TestExtensionInsideTable::field7() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestExtensionInsideTable.field7)
  return field7_;
}
inline void TestExtensionInsideTable::set_field7(::google::protobuf::int32 value) {
  set_has_field7();
  field7_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestExtensionInsideTable.field7)
}

// optional int32 field8 = 8;
inline bool TestExtensionInsideTable::has_field8() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void TestExtensionInsideTable::set_has_field8() {
  _has_bits_[0] |= 0x00000040u;
}
inline void TestExtensionInsideTable::clear_has_field8() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void TestExtensionInsideTable::clear_field8() {
  field8_ = 0;
  clear_has_field8();
}
inline ::google::protobuf::int32 TestExtensionInsideTable::field8() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestExtensionInsideTable.field8)
  return field8_;
}
inline void TestExtensionInsideTable::set_field8(::google::protobuf::int32 value) {
  set_has_field8();
  field8_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestExtensionInsideTable.field8)
}

// optional int32 field9 = 9;
inline bool TestExtensionInsideTable::has_field9() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void TestExtensionInsideTable::set_has_field9() {
  _has_bits_[0] |= 0x00000080u;
}
inline void TestExtensionInsideTable::clear_has_field9() {
  _has_bits_[0] &= ~0x00000080u;
}
inline void TestExtensionInsideTable::clear_field9() {
  field9_ = 0;
  clear_has_field9();
}
inline ::google::protobuf::int32 TestExtensionInsideTable::field9() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestExtensionInsideTable.field9)
  return field9_;
}
inline void TestExtensionInsideTable::set_field9(::google::protobuf::int32 value) {
  set_has_field9();
  field9_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestExtensionInsideTable.field9)
}

// optional int32 field10 = 10;
inline bool TestExtensionInsideTable::has_field10() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void TestExtensionInsideTable::set_has_field10() {
  _has_bits_[0] |= 0x00000100u;
}
inline void TestExtensionInsideTable::clear_has_field10() {
  _has_bits_[0] &= ~0x00000100u;
}
inline void TestExtensionInsideTable::clear_field10() {
  field10_ = 0;
  clear_has_field10();
}
inline ::google::protobuf::int32 TestExtensionInsideTable::field10() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestExtensionInsideTable.field10)
  return field10_;
}
inline void TestExtensionInsideTable::set_field10(::google::protobuf::int32 value) {
  set_has_field10();
  field10_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestExtensionInsideTable.field10)
}

#ifdef __GNUC__
  #pragma GCC diagnostic pop
#endif  // __GNUC__
// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------


// @@protoc_insertion_point(namespace_scope)

}  // namespace protobuf_unittest

namespace google {
namespace protobuf {

template <> struct is_proto_enum< ::protobuf_unittest::TestAllTypes_NestedEnum> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::protobuf_unittest::TestAllTypes_NestedEnum>() {
  return ::protobuf_unittest::TestAllTypes_NestedEnum_descriptor();
}
template <> struct is_proto_enum< ::protobuf_unittest::TestOneof2_NestedEnum> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::protobuf_unittest::TestOneof2_NestedEnum>() {
  return ::protobuf_unittest::TestOneof2_NestedEnum_descriptor();
}
template <> struct is_proto_enum< ::protobuf_unittest::TestDynamicExtensions_DynamicEnumType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::protobuf_unittest::TestDynamicExtensions_DynamicEnumType>() {
  return ::protobuf_unittest::TestDynamicExtensions_DynamicEnumType_descriptor();
}
template <> struct is_proto_enum< ::protobuf_unittest::ForeignEnum> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::protobuf_unittest::ForeignEnum>() {
  return ::protobuf_unittest::ForeignEnum_descriptor();
}
template <> struct is_proto_enum< ::protobuf_unittest::TestEnumWithDupValue> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::protobuf_unittest::TestEnumWithDupValue>() {
  return ::protobuf_unittest::TestEnumWithDupValue_descriptor();
}
template <> struct is_proto_enum< ::protobuf_unittest::TestSparseEnum> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::protobuf_unittest::TestSparseEnum>() {
  return ::protobuf_unittest::TestSparseEnum_descriptor();
}

}  // namespace protobuf
}  // namespace google

// @@protoc_insertion_point(global_scope)

#endif  // PROTOBUF_INCLUDED_google_2fprotobuf_2funittest_2eproto