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

#ifndef PROTOBUF_INCLUDED_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto
#define PROTOBUF_INCLUDED_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_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/generated_enum_reflection.h>
#include <google/protobuf/service.h>
#include <google/protobuf/unknown_field_set.h>
// @@protoc_insertion_point(includes)
#define PROTOBUF_INTERNAL_EXPORT_protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto 

namespace protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_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[17];
  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_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto
namespace protobuf_unittest {
class DummyMessage;
class DummyMessageDefaultTypeInternal;
extern DummyMessageDefaultTypeInternal _DummyMessage_default_instance_;
class Shutdown;
class ShutdownDefaultTypeInternal;
extern ShutdownDefaultTypeInternal _Shutdown_default_instance_;
class TableStruct;
class TableStructDefaultTypeInternal;
extern TableStructDefaultTypeInternal _TableStruct_default_instance_;
class TestConflictingEnumNames;
class TestConflictingEnumNamesDefaultTypeInternal;
extern TestConflictingEnumNamesDefaultTypeInternal _TestConflictingEnumNames_default_instance_;
class TestConflictingSymbolNames;
class TestConflictingSymbolNamesDefaultTypeInternal;
extern TestConflictingSymbolNamesDefaultTypeInternal _TestConflictingSymbolNames_default_instance_;
class TestConflictingSymbolNamesExtension;
class TestConflictingSymbolNamesExtensionDefaultTypeInternal;
extern TestConflictingSymbolNamesExtensionDefaultTypeInternal _TestConflictingSymbolNamesExtension_default_instance_;
class TestConflictingSymbolNames_BuildDescriptors;
class TestConflictingSymbolNames_BuildDescriptorsDefaultTypeInternal;
extern TestConflictingSymbolNames_BuildDescriptorsDefaultTypeInternal _TestConflictingSymbolNames_BuildDescriptors_default_instance_;
class TestConflictingSymbolNames_Cord;
class TestConflictingSymbolNames_CordDefaultTypeInternal;
extern TestConflictingSymbolNames_CordDefaultTypeInternal _TestConflictingSymbolNames_Cord_default_instance_;
class TestConflictingSymbolNames_DO;
class TestConflictingSymbolNames_DODefaultTypeInternal;
extern TestConflictingSymbolNames_DODefaultTypeInternal _TestConflictingSymbolNames_DO_default_instance_;
class TestConflictingSymbolNames_Data1;
class TestConflictingSymbolNames_Data1DefaultTypeInternal;
extern TestConflictingSymbolNames_Data1DefaultTypeInternal _TestConflictingSymbolNames_Data1_default_instance_;
class TestConflictingSymbolNames_Data2;
class TestConflictingSymbolNames_Data2DefaultTypeInternal;
extern TestConflictingSymbolNames_Data2DefaultTypeInternal _TestConflictingSymbolNames_Data2_default_instance_;
class TestConflictingSymbolNames_Data3;
class TestConflictingSymbolNames_Data3DefaultTypeInternal;
extern TestConflictingSymbolNames_Data3DefaultTypeInternal _TestConflictingSymbolNames_Data3_default_instance_;
class TestConflictingSymbolNames_Data4;
class TestConflictingSymbolNames_Data4DefaultTypeInternal;
extern TestConflictingSymbolNames_Data4DefaultTypeInternal _TestConflictingSymbolNames_Data4_default_instance_;
class TestConflictingSymbolNames_Data5;
class TestConflictingSymbolNames_Data5DefaultTypeInternal;
extern TestConflictingSymbolNames_Data5DefaultTypeInternal _TestConflictingSymbolNames_Data5_default_instance_;
class TestConflictingSymbolNames_Data6;
class TestConflictingSymbolNames_Data6DefaultTypeInternal;
extern TestConflictingSymbolNames_Data6DefaultTypeInternal _TestConflictingSymbolNames_Data6_default_instance_;
class TestConflictingSymbolNames_StringPiece;
class TestConflictingSymbolNames_StringPieceDefaultTypeInternal;
extern TestConflictingSymbolNames_StringPieceDefaultTypeInternal _TestConflictingSymbolNames_StringPiece_default_instance_;
class TestConflictingSymbolNames_TypeTraits;
class TestConflictingSymbolNames_TypeTraitsDefaultTypeInternal;
extern TestConflictingSymbolNames_TypeTraitsDefaultTypeInternal _TestConflictingSymbolNames_TypeTraits_default_instance_;
}  // namespace protobuf_unittest
namespace google {
namespace protobuf {
template<> ::protobuf_unittest::DummyMessage* Arena::CreateMaybeMessage<::protobuf_unittest::DummyMessage>(Arena*);
template<> ::protobuf_unittest::Shutdown* Arena::CreateMaybeMessage<::protobuf_unittest::Shutdown>(Arena*);
template<> ::protobuf_unittest::TableStruct* Arena::CreateMaybeMessage<::protobuf_unittest::TableStruct>(Arena*);
template<> ::protobuf_unittest::TestConflictingEnumNames* Arena::CreateMaybeMessage<::protobuf_unittest::TestConflictingEnumNames>(Arena*);
template<> ::protobuf_unittest::TestConflictingSymbolNames* Arena::CreateMaybeMessage<::protobuf_unittest::TestConflictingSymbolNames>(Arena*);
template<> ::protobuf_unittest::TestConflictingSymbolNamesExtension* Arena::CreateMaybeMessage<::protobuf_unittest::TestConflictingSymbolNamesExtension>(Arena*);
template<> ::protobuf_unittest::TestConflictingSymbolNames_BuildDescriptors* Arena::CreateMaybeMessage<::protobuf_unittest::TestConflictingSymbolNames_BuildDescriptors>(Arena*);
template<> ::protobuf_unittest::TestConflictingSymbolNames_Cord* Arena::CreateMaybeMessage<::protobuf_unittest::TestConflictingSymbolNames_Cord>(Arena*);
template<> ::protobuf_unittest::TestConflictingSymbolNames_DO* Arena::CreateMaybeMessage<::protobuf_unittest::TestConflictingSymbolNames_DO>(Arena*);
template<> ::protobuf_unittest::TestConflictingSymbolNames_Data1* Arena::CreateMaybeMessage<::protobuf_unittest::TestConflictingSymbolNames_Data1>(Arena*);
template<> ::protobuf_unittest::TestConflictingSymbolNames_Data2* Arena::CreateMaybeMessage<::protobuf_unittest::TestConflictingSymbolNames_Data2>(Arena*);
template<> ::protobuf_unittest::TestConflictingSymbolNames_Data3* Arena::CreateMaybeMessage<::protobuf_unittest::TestConflictingSymbolNames_Data3>(Arena*);
template<> ::protobuf_unittest::TestConflictingSymbolNames_Data4* Arena::CreateMaybeMessage<::protobuf_unittest::TestConflictingSymbolNames_Data4>(Arena*);
template<> ::protobuf_unittest::TestConflictingSymbolNames_Data5* Arena::CreateMaybeMessage<::protobuf_unittest::TestConflictingSymbolNames_Data5>(Arena*);
template<> ::protobuf_unittest::TestConflictingSymbolNames_Data6* Arena::CreateMaybeMessage<::protobuf_unittest::TestConflictingSymbolNames_Data6>(Arena*);
template<> ::protobuf_unittest::TestConflictingSymbolNames_StringPiece* Arena::CreateMaybeMessage<::protobuf_unittest::TestConflictingSymbolNames_StringPiece>(Arena*);
template<> ::protobuf_unittest::TestConflictingSymbolNames_TypeTraits* Arena::CreateMaybeMessage<::protobuf_unittest::TestConflictingSymbolNames_TypeTraits>(Arena*);
}  // namespace protobuf
}  // namespace google
namespace protobuf_unittest {

enum TestConflictingSymbolNames_TestEnum {
  TestConflictingSymbolNames_TestEnum_FOO = 0
};
bool TestConflictingSymbolNames_TestEnum_IsValid(int value);
const TestConflictingSymbolNames_TestEnum TestConflictingSymbolNames_TestEnum_TestEnum_MIN = TestConflictingSymbolNames_TestEnum_FOO;
const TestConflictingSymbolNames_TestEnum TestConflictingSymbolNames_TestEnum_TestEnum_MAX = TestConflictingSymbolNames_TestEnum_FOO;
const int TestConflictingSymbolNames_TestEnum_TestEnum_ARRAYSIZE = TestConflictingSymbolNames_TestEnum_TestEnum_MAX + 1;

const ::google::protobuf::EnumDescriptor* TestConflictingSymbolNames_TestEnum_descriptor();
inline const ::std::string& TestConflictingSymbolNames_TestEnum_Name(TestConflictingSymbolNames_TestEnum value) {
  return ::google::protobuf::internal::NameOfEnum(
    TestConflictingSymbolNames_TestEnum_descriptor(), value);
}
inline bool TestConflictingSymbolNames_TestEnum_Parse(
    const ::std::string& name, TestConflictingSymbolNames_TestEnum* value) {
  return ::google::protobuf::internal::ParseNamedEnum<TestConflictingSymbolNames_TestEnum>(
    TestConflictingSymbolNames_TestEnum_descriptor(), name, value);
}
enum TestConflictingEnumNames_NestedConflictingEnum {
  TestConflictingEnumNames_NestedConflictingEnum_and_ = 1,
  TestConflictingEnumNames_NestedConflictingEnum_class_ = 2,
  TestConflictingEnumNames_NestedConflictingEnum_int_ = 3,
  TestConflictingEnumNames_NestedConflictingEnum_typedef_ = 4,
  TestConflictingEnumNames_NestedConflictingEnum_XOR = 5
};
bool TestConflictingEnumNames_NestedConflictingEnum_IsValid(int value);
const TestConflictingEnumNames_NestedConflictingEnum TestConflictingEnumNames_NestedConflictingEnum_NestedConflictingEnum_MIN = TestConflictingEnumNames_NestedConflictingEnum_and_;
const TestConflictingEnumNames_NestedConflictingEnum TestConflictingEnumNames_NestedConflictingEnum_NestedConflictingEnum_MAX = TestConflictingEnumNames_NestedConflictingEnum_XOR;
const int TestConflictingEnumNames_NestedConflictingEnum_NestedConflictingEnum_ARRAYSIZE = TestConflictingEnumNames_NestedConflictingEnum_NestedConflictingEnum_MAX + 1;

const ::google::protobuf::EnumDescriptor* TestConflictingEnumNames_NestedConflictingEnum_descriptor();
inline const ::std::string& TestConflictingEnumNames_NestedConflictingEnum_Name(TestConflictingEnumNames_NestedConflictingEnum value) {
  return ::google::protobuf::internal::NameOfEnum(
    TestConflictingEnumNames_NestedConflictingEnum_descriptor(), value);
}
inline bool TestConflictingEnumNames_NestedConflictingEnum_Parse(
    const ::std::string& name, TestConflictingEnumNames_NestedConflictingEnum* value) {
  return ::google::protobuf::internal::ParseNamedEnum<TestConflictingEnumNames_NestedConflictingEnum>(
    TestConflictingEnumNames_NestedConflictingEnum_descriptor(), name, value);
}
enum ConflictingEnum {
  NOT_EQ = 1,
  volatile_ = 2,
  return_ = 3
};
bool ConflictingEnum_IsValid(int value);
const ConflictingEnum ConflictingEnum_MIN = NOT_EQ;
const ConflictingEnum ConflictingEnum_MAX = return_;
const int ConflictingEnum_ARRAYSIZE = ConflictingEnum_MAX + 1;

const ::google::protobuf::EnumDescriptor* ConflictingEnum_descriptor();
inline const ::std::string& ConflictingEnum_Name(ConflictingEnum value) {
  return ::google::protobuf::internal::NameOfEnum(
    ConflictingEnum_descriptor(), value);
}
inline bool ConflictingEnum_Parse(
    const ::std::string& name, ConflictingEnum* value) {
  return ::google::protobuf::internal::ParseNamedEnum<ConflictingEnum>(
    ConflictingEnum_descriptor(), name, value);
}
// ===================================================================

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

  TestConflictingSymbolNames_BuildDescriptors(const TestConflictingSymbolNames_BuildDescriptors& from);

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

  inline TestConflictingSymbolNames_BuildDescriptors& operator=(TestConflictingSymbolNames_BuildDescriptors&& 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();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const TestConflictingSymbolNames_BuildDescriptors& default_instance();

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

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

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

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

  TestConflictingSymbolNames_BuildDescriptors* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestConflictingSymbolNames_BuildDescriptors>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestConflictingSymbolNames_BuildDescriptors& from);
  void MergeFrom(const TestConflictingSymbolNames_BuildDescriptors& 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(TestConflictingSymbolNames_BuildDescriptors* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

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

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

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

  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestConflictingSymbolNames.BuildDescriptors)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::TableStruct;
};
// -------------------------------------------------------------------

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

  TestConflictingSymbolNames_TypeTraits(const TestConflictingSymbolNames_TypeTraits& from);

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

  inline TestConflictingSymbolNames_TypeTraits& operator=(TestConflictingSymbolNames_TypeTraits&& 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();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const TestConflictingSymbolNames_TypeTraits& default_instance();

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

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

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

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

  TestConflictingSymbolNames_TypeTraits* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestConflictingSymbolNames_TypeTraits>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestConflictingSymbolNames_TypeTraits& from);
  void MergeFrom(const TestConflictingSymbolNames_TypeTraits& 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(TestConflictingSymbolNames_TypeTraits* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

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

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

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

  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestConflictingSymbolNames.TypeTraits)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::TableStruct;
};
// -------------------------------------------------------------------

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

  TestConflictingSymbolNames_Data1(const TestConflictingSymbolNames_Data1& from);

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

  inline TestConflictingSymbolNames_Data1& operator=(TestConflictingSymbolNames_Data1&& 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();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const TestConflictingSymbolNames_Data1& default_instance();

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

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

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

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

  TestConflictingSymbolNames_Data1* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestConflictingSymbolNames_Data1>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestConflictingSymbolNames_Data1& from);
  void MergeFrom(const TestConflictingSymbolNames_Data1& 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(TestConflictingSymbolNames_Data1* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

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

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

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

  // repeated int32 data = 1;
  int data_size() const;
  void clear_data();
  static const int kDataFieldNumber = 1;
  ::google::protobuf::int32 data(int index) const;
  void set_data(int index, ::google::protobuf::int32 value);
  void add_data(::google::protobuf::int32 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
      data() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
      mutable_data();

  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestConflictingSymbolNames.Data1)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > data_;
  friend struct ::protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::TableStruct;
};
// -------------------------------------------------------------------

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

  TestConflictingSymbolNames_Data2(const TestConflictingSymbolNames_Data2& from);

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

  inline TestConflictingSymbolNames_Data2& operator=(TestConflictingSymbolNames_Data2&& 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();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const TestConflictingSymbolNames_Data2& default_instance();

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

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

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

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

  TestConflictingSymbolNames_Data2* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestConflictingSymbolNames_Data2>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestConflictingSymbolNames_Data2& from);
  void MergeFrom(const TestConflictingSymbolNames_Data2& 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(TestConflictingSymbolNames_Data2* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

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

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

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

  // repeated .protobuf_unittest.TestConflictingSymbolNames.TestEnum data = 1;
  int data_size() const;
  void clear_data();
  static const int kDataFieldNumber = 1;
  ::protobuf_unittest::TestConflictingSymbolNames_TestEnum data(int index) const;
  void set_data(int index, ::protobuf_unittest::TestConflictingSymbolNames_TestEnum value);
  void add_data(::protobuf_unittest::TestConflictingSymbolNames_TestEnum value);
  const ::google::protobuf::RepeatedField<int>& data() const;
  ::google::protobuf::RepeatedField<int>* mutable_data();

  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestConflictingSymbolNames.Data2)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::RepeatedField<int> data_;
  friend struct ::protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::TableStruct;
};
// -------------------------------------------------------------------

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

  TestConflictingSymbolNames_Data3(const TestConflictingSymbolNames_Data3& from);

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

  inline TestConflictingSymbolNames_Data3& operator=(TestConflictingSymbolNames_Data3&& 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();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const TestConflictingSymbolNames_Data3& default_instance();

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

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

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

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

  TestConflictingSymbolNames_Data3* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestConflictingSymbolNames_Data3>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestConflictingSymbolNames_Data3& from);
  void MergeFrom(const TestConflictingSymbolNames_Data3& 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(TestConflictingSymbolNames_Data3* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  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.TestConflictingSymbolNames.Data3)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::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_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::TableStruct;
};
// -------------------------------------------------------------------

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

  TestConflictingSymbolNames_Data4(const TestConflictingSymbolNames_Data4& from);

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

  inline TestConflictingSymbolNames_Data4& operator=(TestConflictingSymbolNames_Data4&& 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();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const TestConflictingSymbolNames_Data4& default_instance();

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

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

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

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

  TestConflictingSymbolNames_Data4* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestConflictingSymbolNames_Data4>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestConflictingSymbolNames_Data4& from);
  void MergeFrom(const TestConflictingSymbolNames_Data4& 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(TestConflictingSymbolNames_Data4* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

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

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

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

  // repeated .protobuf_unittest.TestConflictingSymbolNames.Data4 data = 1;
  int data_size() const;
  void clear_data();
  static const int kDataFieldNumber = 1;
  ::protobuf_unittest::TestConflictingSymbolNames_Data4* mutable_data(int index);
  ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::TestConflictingSymbolNames_Data4 >*
      mutable_data();
  const ::protobuf_unittest::TestConflictingSymbolNames_Data4& data(int index) const;
  ::protobuf_unittest::TestConflictingSymbolNames_Data4* add_data();
  const ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::TestConflictingSymbolNames_Data4 >&
      data() const;

  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestConflictingSymbolNames.Data4)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::TestConflictingSymbolNames_Data4 > data_;
  friend struct ::protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::TableStruct;
};
// -------------------------------------------------------------------

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

  TestConflictingSymbolNames_Data5(const TestConflictingSymbolNames_Data5& from);

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

  inline TestConflictingSymbolNames_Data5& operator=(TestConflictingSymbolNames_Data5&& 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();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const TestConflictingSymbolNames_Data5& default_instance();

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

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

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

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

  TestConflictingSymbolNames_Data5* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestConflictingSymbolNames_Data5>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestConflictingSymbolNames_Data5& from);
  void MergeFrom(const TestConflictingSymbolNames_Data5& 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(TestConflictingSymbolNames_Data5* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

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

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

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

  // repeated string data = 1 [ctype = STRING_PIECE];
  int data_size() const;
  void clear_data();
  static const int kDataFieldNumber = 1;
 private:
  // Hidden due to unknown ctype option.
  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();
 public:

  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestConflictingSymbolNames.Data5)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::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_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::TableStruct;
};
// -------------------------------------------------------------------

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

  TestConflictingSymbolNames_Data6(const TestConflictingSymbolNames_Data6& from);

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

  inline TestConflictingSymbolNames_Data6& operator=(TestConflictingSymbolNames_Data6&& 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();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const TestConflictingSymbolNames_Data6& default_instance();

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

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

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

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

  TestConflictingSymbolNames_Data6* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestConflictingSymbolNames_Data6>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestConflictingSymbolNames_Data6& from);
  void MergeFrom(const TestConflictingSymbolNames_Data6& 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(TestConflictingSymbolNames_Data6* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

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

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

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

  // repeated string data = 1 [ctype = CORD];
  int data_size() const;
  void clear_data();
  static const int kDataFieldNumber = 1;
 private:
  // Hidden due to unknown ctype option.
  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();
 public:

  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestConflictingSymbolNames.Data6)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::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_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::TableStruct;
};
// -------------------------------------------------------------------

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

  TestConflictingSymbolNames_Cord(const TestConflictingSymbolNames_Cord& from);

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

  inline TestConflictingSymbolNames_Cord& operator=(TestConflictingSymbolNames_Cord&& 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();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const TestConflictingSymbolNames_Cord& default_instance();

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

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

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

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

  TestConflictingSymbolNames_Cord* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestConflictingSymbolNames_Cord>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestConflictingSymbolNames_Cord& from);
  void MergeFrom(const TestConflictingSymbolNames_Cord& 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(TestConflictingSymbolNames_Cord* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

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

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

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

  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestConflictingSymbolNames.Cord)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::TableStruct;
};
// -------------------------------------------------------------------

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

  TestConflictingSymbolNames_StringPiece(const TestConflictingSymbolNames_StringPiece& from);

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

  inline TestConflictingSymbolNames_StringPiece& operator=(TestConflictingSymbolNames_StringPiece&& 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();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const TestConflictingSymbolNames_StringPiece& default_instance();

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

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

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

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

  TestConflictingSymbolNames_StringPiece* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestConflictingSymbolNames_StringPiece>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestConflictingSymbolNames_StringPiece& from);
  void MergeFrom(const TestConflictingSymbolNames_StringPiece& 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(TestConflictingSymbolNames_StringPiece* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

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

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

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

  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestConflictingSymbolNames.StringPiece)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::TableStruct;
};
// -------------------------------------------------------------------

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

  TestConflictingSymbolNames_DO(const TestConflictingSymbolNames_DO& from);

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

  inline TestConflictingSymbolNames_DO& operator=(TestConflictingSymbolNames_DO&& 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();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const TestConflictingSymbolNames_DO& default_instance();

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

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

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

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

  TestConflictingSymbolNames_DO* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestConflictingSymbolNames_DO>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestConflictingSymbolNames_DO& from);
  void MergeFrom(const TestConflictingSymbolNames_DO& 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(TestConflictingSymbolNames_DO* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

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

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

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

  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestConflictingSymbolNames.DO)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::TableStruct;
};
// -------------------------------------------------------------------

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

  TestConflictingSymbolNames(const TestConflictingSymbolNames& from);

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

  inline TestConflictingSymbolNames& operator=(TestConflictingSymbolNames&& 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();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const TestConflictingSymbolNames& default_instance();

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

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

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

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

  TestConflictingSymbolNames* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestConflictingSymbolNames>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestConflictingSymbolNames& from);
  void MergeFrom(const TestConflictingSymbolNames& 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(TestConflictingSymbolNames* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

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

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

  typedef TestConflictingSymbolNames_BuildDescriptors BuildDescriptors;
  typedef TestConflictingSymbolNames_TypeTraits TypeTraits;
  typedef TestConflictingSymbolNames_Data1 Data1;
  typedef TestConflictingSymbolNames_Data2 Data2;
  typedef TestConflictingSymbolNames_Data3 Data3;
  typedef TestConflictingSymbolNames_Data4 Data4;
  typedef TestConflictingSymbolNames_Data5 Data5;
  typedef TestConflictingSymbolNames_Data6 Data6;
  typedef TestConflictingSymbolNames_Cord Cord;
  typedef TestConflictingSymbolNames_StringPiece StringPiece;
  typedef TestConflictingSymbolNames_DO DO;

  typedef TestConflictingSymbolNames_TestEnum TestEnum;
  static const TestEnum FOO =
    TestConflictingSymbolNames_TestEnum_FOO;
  static inline bool TestEnum_IsValid(int value) {
    return TestConflictingSymbolNames_TestEnum_IsValid(value);
  }
  static const TestEnum TestEnum_MIN =
    TestConflictingSymbolNames_TestEnum_TestEnum_MIN;
  static const TestEnum TestEnum_MAX =
    TestConflictingSymbolNames_TestEnum_TestEnum_MAX;
  static const int TestEnum_ARRAYSIZE =
    TestConflictingSymbolNames_TestEnum_TestEnum_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  TestEnum_descriptor() {
    return TestConflictingSymbolNames_TestEnum_descriptor();
  }
  static inline const ::std::string& TestEnum_Name(TestEnum value) {
    return TestConflictingSymbolNames_TestEnum_Name(value);
  }
  static inline bool TestEnum_Parse(const ::std::string& name,
      TestEnum* value) {
    return TestConflictingSymbolNames_TestEnum_Parse(name, value);
  }

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

  // repeated int32 i = 4;
  int i_size() const;
  void clear_i();
  static const int kIFieldNumber = 4;
  ::google::protobuf::int32 i(int index) const;
  void set_i(int index, ::google::protobuf::int32 value);
  void add_i(::google::protobuf::int32 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
      i() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
      mutable_i();

  // repeated string new_element = 5 [ctype = STRING_PIECE];
  int new_element_size() const;
  void clear_new_element();
  static const int kNewElementFieldNumber = 5;
 private:
  // Hidden due to unknown ctype option.
  const ::std::string& new_element(int index) const;
  ::std::string* mutable_new_element(int index);
  void set_new_element(int index, const ::std::string& value);
  #if LANG_CXX11
  void set_new_element(int index, ::std::string&& value);
  #endif
  void set_new_element(int index, const char* value);
  void set_new_element(int index, const char* value, size_t size);
  ::std::string* add_new_element();
  void add_new_element(const ::std::string& value);
  #if LANG_CXX11
  void add_new_element(::std::string&& value);
  #endif
  void add_new_element(const char* value);
  void add_new_element(const char* value, size_t size);
  const ::google::protobuf::RepeatedPtrField< ::std::string>& new_element() const;
  ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_new_element();
 public:

  // repeated int32 index = 13;
  int index_size() const;
  void clear_index();
  static const int kIndexFieldNumber = 13;
  ::google::protobuf::int32 index(int index) const;
  void set_index(int index, ::google::protobuf::int32 value);
  void add_index(::google::protobuf::int32 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
      index() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
      mutable_index();

  // optional string length = 3;
  bool has_length() const;
  void clear_length();
  static const int kLengthFieldNumber = 3;
  const ::std::string& length() const;
  void set_length(const ::std::string& value);
  #if LANG_CXX11
  void set_length(::std::string&& value);
  #endif
  void set_length(const char* value);
  void set_length(const char* value, size_t size);
  ::std::string* mutable_length();
  ::std::string* release_length__();
  void set_allocated_length(::std::string* length);

  // optional string string = 18;
  bool has_string() const;
  void clear_string();
  static const int kStringFieldNumber = 18;
  const ::std::string& string() const;
  void set_string(const ::std::string& value);
  #if LANG_CXX11
  void set_string(::std::string&& value);
  #endif
  void set_string(const char* value);
  void set_string(const char* value, size_t size);
  ::std::string* mutable_string();
  ::std::string* release_string();
  void set_allocated_string(::std::string* string);

  // optional string some_cord = 28 [ctype = CORD];
  bool has_some_cord() const;
  void clear_some_cord();
  static const int kSomeCordFieldNumber = 28;
 private:
  // Hidden due to unknown ctype option.
  const ::std::string& some_cord() const;
  void set_some_cord(const ::std::string& value);
  #if LANG_CXX11
  void set_some_cord(::std::string&& value);
  #endif
  void set_some_cord(const char* value);
  void set_some_cord(const char* value, size_t size);
  ::std::string* mutable_some_cord();
  ::std::string* release_some_cord();
  void set_allocated_some_cord(::std::string* some_cord);
 public:

  // optional string some_string_piece = 29 [ctype = STRING_PIECE];
  bool has_some_string_piece() const;
  void clear_some_string_piece();
  static const int kSomeStringPieceFieldNumber = 29;
 private:
  // Hidden due to unknown ctype option.
  const ::std::string& some_string_piece() const;
  void set_some_string_piece(const ::std::string& value);
  #if LANG_CXX11
  void set_some_string_piece(::std::string&& value);
  #endif
  void set_some_string_piece(const char* value);
  void set_some_string_piece(const char* value, size_t size);
  ::std::string* mutable_some_string_piece();
  ::std::string* release_some_string_piece();
  void set_allocated_some_string_piece(::std::string* some_string_piece);
 public:

  // optional string release_length = 35;
  bool has_release_length() const;
  void clear_release_length();
  static const int kReleaseLengthFieldNumber = 35;
  const ::std::string& release_length() const;
  void set_release_length(const ::std::string& value);
  #if LANG_CXX11
  void set_release_length(::std::string&& value);
  #endif
  void set_release_length(const char* value);
  void set_release_length(const char* value, size_t size);
  ::std::string* mutable_release_length();
  ::std::string* release_release_length();
  void set_allocated_release_length(::std::string* release_length);

  // optional string target = 38;
  bool has_target() const;
  void clear_target();
  static const int kTargetFieldNumber = 38;
  const ::std::string& target() const;
  void set_target(const ::std::string& value);
  #if LANG_CXX11
  void set_target(::std::string&& value);
  #endif
  void set_target(const char* value);
  void set_target(const char* value, size_t size);
  ::std::string* mutable_target();
  ::std::string* release_target();
  void set_allocated_target(::std::string* target);

  // optional .protobuf_unittest.TestConflictingSymbolNames.DO do = 32;
  bool has_do_() const;
  void clear_do_();
  static const int kDoFieldNumber = 32;
  private:
  const ::protobuf_unittest::TestConflictingSymbolNames_DO& _internal_do_() const;
  public:
  const ::protobuf_unittest::TestConflictingSymbolNames_DO& do_() const;
  ::protobuf_unittest::TestConflictingSymbolNames_DO* release_do__();
  ::protobuf_unittest::TestConflictingSymbolNames_DO* mutable_do_();
  void set_allocated_do_(::protobuf_unittest::TestConflictingSymbolNames_DO* do_);

  // optional .protobuf_unittest.TestConflictingSymbolNames.DO release_do = 36;
  bool has_release_do() const;
  void clear_release_do();
  static const int kReleaseDoFieldNumber = 36;
  private:
  const ::protobuf_unittest::TestConflictingSymbolNames_DO& _internal_release_do() const;
  public:
  const ::protobuf_unittest::TestConflictingSymbolNames_DO& release_do() const;
  ::protobuf_unittest::TestConflictingSymbolNames_DO* release_release_do();
  ::protobuf_unittest::TestConflictingSymbolNames_DO* mutable_release_do();
  void set_allocated_release_do(::protobuf_unittest::TestConflictingSymbolNames_DO* release_do);

  // optional int32 input = 1;
  bool has_input() const;
  void clear_input();
  static const int kInputFieldNumber = 1;
  ::google::protobuf::int32 input() const;
  void set_input(::google::protobuf::int32 value);

  // optional int32 output = 2;
  bool has_output() const;
  void clear_output();
  static const int kOutputFieldNumber = 2;
  ::google::protobuf::int32 output() const;
  void set_output(::google::protobuf::int32 value);

  // optional int32 total_size = 6;
  bool has_total_size() const;
  void clear_total_size();
  static const int kTotalSizeFieldNumber = 6;
  ::google::protobuf::int32 total_size() const;
  void set_total_size(::google::protobuf::int32 value);

  // optional int32 tag = 7;
  bool has_tag() const;
  void clear_tag();
  static const int kTagFieldNumber = 7;
  ::google::protobuf::int32 tag() const;
  void set_tag(::google::protobuf::int32 value);

  // optional int32 source = 8;
  bool has_source() const;
  void clear_source();
  static const int kSourceFieldNumber = 8;
  ::google::protobuf::int32 source() const;
  void set_source(::google::protobuf::int32 value);

  // optional int32 value = 9;
  bool has_value() const;
  void clear_value();
  static const int kValueFieldNumber = 9;
  ::google::protobuf::int32 value() const;
  void set_value(::google::protobuf::int32 value);

  // optional int32 file = 10;
  bool has_file() const;
  void clear_file();
  static const int kFileFieldNumber = 10;
  ::google::protobuf::int32 file() const;
  void set_file(::google::protobuf::int32 value);

  // optional int32 from = 11;
  bool has_from() const;
  void clear_from();
  static const int kFromFieldNumber = 11;
  ::google::protobuf::int32 from() const;
  void set_from(::google::protobuf::int32 value);

  // optional int32 handle_uninterpreted = 12;
  bool has_handle_uninterpreted() const;
  void clear_handle_uninterpreted();
  static const int kHandleUninterpretedFieldNumber = 12;
  ::google::protobuf::int32 handle_uninterpreted() const;
  void set_handle_uninterpreted(::google::protobuf::int32 value);

  // optional int32 controller = 14;
  bool has_controller() const;
  void clear_controller();
  static const int kControllerFieldNumber = 14;
  ::google::protobuf::int32 controller() const;
  void set_controller(::google::protobuf::int32 value);

  // optional int32 already_here = 15;
  bool has_already_here() const;
  void clear_already_here();
  static const int kAlreadyHereFieldNumber = 15;
  ::google::protobuf::int32 already_here() const;
  void set_already_here(::google::protobuf::int32 value);

  // optional uint32 uint32 = 16;
  bool has_uint32() const;
  void clear_uint32();
  static const int kUint32FieldNumber = 16;
  ::google::protobuf::uint32 uint32() const;
  void set_uint32(::google::protobuf::uint32 value);

  // optional uint64 uint64 = 17;
  bool has_uint64() const;
  void clear_uint64();
  static const int kUint64FieldNumber = 17;
  ::google::protobuf::uint64 uint64() const;
  void set_uint64(::google::protobuf::uint64 value);

  // optional int32 memset = 19;
  bool has_memset() const;
  void clear_memset();
  static const int kMemsetFieldNumber = 19;
  ::google::protobuf::int32 memset() const;
  void set_memset(::google::protobuf::int32 value);

  // optional int32 int32 = 20;
  bool has_int32() const;
  void clear_int32();
  static const int kInt32FieldNumber = 20;
  ::google::protobuf::int32 int32() const;
  void set_int32(::google::protobuf::int32 value);

  // optional int64 int64 = 21;
  bool has_int64() const;
  void clear_int64();
  static const int kInt64FieldNumber = 21;
  ::google::protobuf::int64 int64() const;
  void set_int64(::google::protobuf::int64 value);

  // optional uint32 cached_size = 22;
  bool has_cached_size() const;
  void clear_cached_size();
  static const int kCachedSizeFieldNumber = 22;
  ::google::protobuf::uint32 cached_size() const;
  void set_cached_size(::google::protobuf::uint32 value);

  // optional uint32 extensions = 23;
  bool has_extensions() const;
  void clear_extensions();
  static const int kExtensionsFieldNumber = 23;
  ::google::protobuf::uint32 extensions() const;
  void set_extensions(::google::protobuf::uint32 value);

  // optional uint32 bit = 24;
  bool has_bit() const;
  void clear_bit();
  static const int kBitFieldNumber = 24;
  ::google::protobuf::uint32 bit() const;
  void set_bit(::google::protobuf::uint32 value);

  // optional uint32 bits = 25;
  bool has_bits() const;
  void clear_bits();
  static const int kBitsFieldNumber = 25;
  ::google::protobuf::uint32 bits() const;
  void set_bits(::google::protobuf::uint32 value);

  // optional uint32 offsets = 26;
  bool has_offsets() const;
  void clear_offsets();
  static const int kOffsetsFieldNumber = 26;
  ::google::protobuf::uint32 offsets() const;
  void set_offsets(::google::protobuf::uint32 value);

  // optional uint32 reflection = 27;
  bool has_reflection() const;
  void clear_reflection();
  static const int kReflectionFieldNumber = 27;
  ::google::protobuf::uint32 reflection() const;
  void set_reflection(::google::protobuf::uint32 value);

  // optional uint32 int = 30;
  bool has_int_() const;
  void clear_int_();
  static const int kIntFieldNumber = 30;
  ::google::protobuf::uint32 int_() const;
  void set_int_(::google::protobuf::uint32 value);

  // optional uint32 friend = 31;
  bool has_friend_() const;
  void clear_friend_();
  static const int kFriendFieldNumber = 31;
  ::google::protobuf::uint32 friend_() const;
  void set_friend_(::google::protobuf::uint32 value);

  // optional int32 field_type = 33;
  bool has_field_type() const;
  void clear_field_type();
  static const int kFieldTypeFieldNumber = 33;
  ::google::protobuf::int32 field_type() const;
  void set_field_type(::google::protobuf::int32 value);

  // optional bool is_packed = 34;
  bool has_is_packed() const;
  void clear_is_packed();
  static const int kIsPackedFieldNumber = 34;
  bool is_packed() const;
  void set_is_packed(bool value);

  // optional uint32 class = 37;
  bool has_class_() const;
  void clear_class_();
  static const int kClassFieldNumber = 37;
  ::google::protobuf::uint32 class_() const;
  void set_class_(::google::protobuf::uint32 value);

  // optional uint32 typedecl = 39;
  bool has_typedecl() const;
  void clear_typedecl();
  static const int kTypedeclFieldNumber = 39;
  ::google::protobuf::uint32 typedecl() const;
  void set_typedecl(::google::protobuf::uint32 value);

  // optional uint32 auto = 40;
  bool has_auto_() const;
  void clear_auto_();
  static const int kAutoFieldNumber = 40;
  ::google::protobuf::uint32 auto_() const;
  void set_auto_(::google::protobuf::uint32 value);

  GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(TestConflictingSymbolNames)
  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestConflictingSymbolNames)
 private:
  void set_has_input();
  void clear_has_input();
  void set_has_output();
  void clear_has_output();
  void set_has_length();
  void clear_has_length();
  void set_has_total_size();
  void clear_has_total_size();
  void set_has_tag();
  void clear_has_tag();
  void set_has_source();
  void clear_has_source();
  void set_has_value();
  void clear_has_value();
  void set_has_file();
  void clear_has_file();
  void set_has_from();
  void clear_has_from();
  void set_has_handle_uninterpreted();
  void clear_has_handle_uninterpreted();
  void set_has_controller();
  void clear_has_controller();
  void set_has_already_here();
  void clear_has_already_here();
  void set_has_uint32();
  void clear_has_uint32();
  void set_has_uint64();
  void clear_has_uint64();
  void set_has_string();
  void clear_has_string();
  void set_has_memset();
  void clear_has_memset();
  void set_has_int32();
  void clear_has_int32();
  void set_has_int64();
  void clear_has_int64();
  void set_has_cached_size();
  void clear_has_cached_size();
  void set_has_extensions();
  void clear_has_extensions();
  void set_has_bit();
  void clear_has_bit();
  void set_has_bits();
  void clear_has_bits();
  void set_has_offsets();
  void clear_has_offsets();
  void set_has_reflection();
  void clear_has_reflection();
  void set_has_some_cord();
  void clear_has_some_cord();
  void set_has_some_string_piece();
  void clear_has_some_string_piece();
  void set_has_int_();
  void clear_has_int_();
  void set_has_friend_();
  void clear_has_friend_();
  void set_has_class_();
  void clear_has_class_();
  void set_has_typedecl();
  void clear_has_typedecl();
  void set_has_auto_();
  void clear_has_auto_();
  void set_has_do_();
  void clear_has_do_();
  void set_has_field_type();
  void clear_has_field_type();
  void set_has_is_packed();
  void clear_has_is_packed();
  void set_has_release_length();
  void clear_has_release_length();
  void set_has_release_do();
  void clear_has_release_do();
  void set_has_target();
  void clear_has_target();

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

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<2> _has_bits_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > i_;
  ::google::protobuf::RepeatedPtrField< ::std::string> new_element_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > index_;
  ::google::protobuf::internal::ArenaStringPtr length_;
  ::google::protobuf::internal::ArenaStringPtr string_;
  ::google::protobuf::internal::ArenaStringPtr some_cord_;
  ::google::protobuf::internal::ArenaStringPtr some_string_piece_;
  ::google::protobuf::internal::ArenaStringPtr release_length_;
  ::google::protobuf::internal::ArenaStringPtr target_;
  ::protobuf_unittest::TestConflictingSymbolNames_DO* do__;
  ::protobuf_unittest::TestConflictingSymbolNames_DO* release_do_;
  ::google::protobuf::int32 input_;
  ::google::protobuf::int32 output_;
  ::google::protobuf::int32 total_size_;
  ::google::protobuf::int32 tag_;
  ::google::protobuf::int32 source_;
  ::google::protobuf::int32 value_;
  ::google::protobuf::int32 file_;
  ::google::protobuf::int32 from_;
  ::google::protobuf::int32 handle_uninterpreted_;
  ::google::protobuf::int32 controller_;
  ::google::protobuf::int32 already_here_;
  ::google::protobuf::uint32 uint32_;
  ::google::protobuf::uint64 uint64_;
  ::google::protobuf::int32 memset_;
  ::google::protobuf::int32 int32_;
  ::google::protobuf::int64 int64_;
  ::google::protobuf::uint32 cached_size_;
  ::google::protobuf::uint32 extensions_;
  ::google::protobuf::uint32 bit_;
  ::google::protobuf::uint32 bits_;
  ::google::protobuf::uint32 offsets_;
  ::google::protobuf::uint32 reflection_;
  ::google::protobuf::uint32 int__;
  ::google::protobuf::uint32 friend__;
  ::google::protobuf::int32 field_type_;
  bool is_packed_;
  ::google::protobuf::uint32 class__;
  ::google::protobuf::uint32 typedecl_;
  ::google::protobuf::uint32 auto__;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::TableStruct;
};
// -------------------------------------------------------------------

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

  TestConflictingSymbolNamesExtension(const TestConflictingSymbolNamesExtension& from);

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

  inline TestConflictingSymbolNamesExtension& operator=(TestConflictingSymbolNamesExtension&& 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();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const TestConflictingSymbolNamesExtension& default_instance();

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

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

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

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

  TestConflictingSymbolNamesExtension* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestConflictingSymbolNamesExtension>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestConflictingSymbolNamesExtension& from);
  void MergeFrom(const TestConflictingSymbolNamesExtension& 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(TestConflictingSymbolNamesExtension* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

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

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

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

  static const int kRepeatedInt32ExtFieldNumber = 20423638;
  static ::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestConflictingSymbolNames,
      ::google::protobuf::internal::RepeatedPrimitiveTypeTraits< ::google::protobuf::int32 >, 5, true >
    repeated_int32_ext;
  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestConflictingSymbolNamesExtension)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::TableStruct;
};
// -------------------------------------------------------------------

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

  TestConflictingEnumNames(const TestConflictingEnumNames& from);

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

  inline TestConflictingEnumNames& operator=(TestConflictingEnumNames&& 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();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const TestConflictingEnumNames& default_instance();

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

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

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

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

  TestConflictingEnumNames* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestConflictingEnumNames>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestConflictingEnumNames& from);
  void MergeFrom(const TestConflictingEnumNames& 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(TestConflictingEnumNames* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

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

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

  typedef TestConflictingEnumNames_NestedConflictingEnum NestedConflictingEnum;
  static const NestedConflictingEnum and_ =
    TestConflictingEnumNames_NestedConflictingEnum_and_;
  static const NestedConflictingEnum class_ =
    TestConflictingEnumNames_NestedConflictingEnum_class_;
  static const NestedConflictingEnum int_ =
    TestConflictingEnumNames_NestedConflictingEnum_int_;
  static const NestedConflictingEnum typedef_ =
    TestConflictingEnumNames_NestedConflictingEnum_typedef_;
  static const NestedConflictingEnum XOR =
    TestConflictingEnumNames_NestedConflictingEnum_XOR;
  static inline bool NestedConflictingEnum_IsValid(int value) {
    return TestConflictingEnumNames_NestedConflictingEnum_IsValid(value);
  }
  static const NestedConflictingEnum NestedConflictingEnum_MIN =
    TestConflictingEnumNames_NestedConflictingEnum_NestedConflictingEnum_MIN;
  static const NestedConflictingEnum NestedConflictingEnum_MAX =
    TestConflictingEnumNames_NestedConflictingEnum_NestedConflictingEnum_MAX;
  static const int NestedConflictingEnum_ARRAYSIZE =
    TestConflictingEnumNames_NestedConflictingEnum_NestedConflictingEnum_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  NestedConflictingEnum_descriptor() {
    return TestConflictingEnumNames_NestedConflictingEnum_descriptor();
  }
  static inline const ::std::string& NestedConflictingEnum_Name(NestedConflictingEnum value) {
    return TestConflictingEnumNames_NestedConflictingEnum_Name(value);
  }
  static inline bool NestedConflictingEnum_Parse(const ::std::string& name,
      NestedConflictingEnum* value) {
    return TestConflictingEnumNames_NestedConflictingEnum_Parse(name, value);
  }

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

  // optional .protobuf_unittest.TestConflictingEnumNames.NestedConflictingEnum conflicting_enum = 1;
  bool has_conflicting_enum() const;
  void clear_conflicting_enum();
  static const int kConflictingEnumFieldNumber = 1;
  ::protobuf_unittest::TestConflictingEnumNames_NestedConflictingEnum conflicting_enum() const;
  void set_conflicting_enum(::protobuf_unittest::TestConflictingEnumNames_NestedConflictingEnum value);

  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestConflictingEnumNames)
 private:
  void set_has_conflicting_enum();
  void clear_has_conflicting_enum();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  int conflicting_enum_;
  friend struct ::protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::TableStruct;
};
// -------------------------------------------------------------------

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

  DummyMessage(const DummyMessage& from);

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

  inline DummyMessage& operator=(DummyMessage&& 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();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const DummyMessage& default_instance();

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

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

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

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

  DummyMessage* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<DummyMessage>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const DummyMessage& from);
  void MergeFrom(const DummyMessage& 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(DummyMessage* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

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

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

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

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

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::TableStruct;
};
// -------------------------------------------------------------------

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

  Shutdown(const Shutdown& from);

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

  inline Shutdown& operator=(Shutdown&& 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();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const Shutdown& default_instance();

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

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

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

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

  Shutdown* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<Shutdown>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const Shutdown& from);
  void MergeFrom(const Shutdown& 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(Shutdown* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

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

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

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

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

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::TableStruct;
};
// -------------------------------------------------------------------

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

  TableStruct(const TableStruct& from);

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

  inline TableStruct& operator=(TableStruct&& 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();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const TableStruct& default_instance();

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

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

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

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

  TableStruct* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TableStruct>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TableStruct& from);
  void MergeFrom(const TableStruct& 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(TableStruct* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

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

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

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

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

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::TableStruct;
};
// ===================================================================

class TestConflictingMethodNames_Stub;

class TestConflictingMethodNames : public ::google::protobuf::Service {
 protected:
  // This class should be treated as an abstract interface.
  inline TestConflictingMethodNames() {};
 public:
  virtual ~TestConflictingMethodNames();

  typedef TestConflictingMethodNames_Stub Stub;

  static const ::google::protobuf::ServiceDescriptor* descriptor();

  virtual void Closure(::google::protobuf::RpcController* controller,
                       const ::protobuf_unittest::DummyMessage* request,
                       ::protobuf_unittest::DummyMessage* 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(TestConflictingMethodNames);
};

class TestConflictingMethodNames_Stub : public TestConflictingMethodNames {
 public:
  TestConflictingMethodNames_Stub(::google::protobuf::RpcChannel* channel);
  TestConflictingMethodNames_Stub(::google::protobuf::RpcChannel* channel,
                   ::google::protobuf::Service::ChannelOwnership ownership);
  ~TestConflictingMethodNames_Stub();

  inline ::google::protobuf::RpcChannel* channel() { return channel_; }

  // implements TestConflictingMethodNames ------------------------------------------

  void Closure(::google::protobuf::RpcController* controller,
                       const ::protobuf_unittest::DummyMessage* request,
                       ::protobuf_unittest::DummyMessage* response,
                       ::google::protobuf::Closure* done);
 private:
  ::google::protobuf::RpcChannel* channel_;
  bool owns_channel_;
  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(TestConflictingMethodNames_Stub);
};


// ===================================================================


// ===================================================================

#ifdef __GNUC__
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// TestConflictingSymbolNames_BuildDescriptors

// -------------------------------------------------------------------

// TestConflictingSymbolNames_TypeTraits

// -------------------------------------------------------------------

// TestConflictingSymbolNames_Data1

// repeated int32 data = 1;
inline int TestConflictingSymbolNames_Data1::data_size() const {
  return data_.size();
}
inline void TestConflictingSymbolNames_Data1::clear_data() {
  data_.Clear();
}
inline ::google::protobuf::int32 TestConflictingSymbolNames_Data1::data(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestConflictingSymbolNames.Data1.data)
  return data_.Get(index);
}
inline void TestConflictingSymbolNames_Data1::set_data(int index, ::google::protobuf::int32 value) {
  data_.Set(index, value);
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestConflictingSymbolNames.Data1.data)
}
inline void TestConflictingSymbolNames_Data1::add_data(::google::protobuf::int32 value) {
  data_.Add(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestConflictingSymbolNames.Data1.data)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
TestConflictingSymbolNames_Data1::data() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestConflictingSymbolNames.Data1.data)
  return data_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
TestConflictingSymbolNames_Data1::mutable_data() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestConflictingSymbolNames.Data1.data)
  return &data_;
}

// -------------------------------------------------------------------

// TestConflictingSymbolNames_Data2

// repeated .protobuf_unittest.TestConflictingSymbolNames.TestEnum data = 1;
inline int TestConflictingSymbolNames_Data2::data_size() const {
  return data_.size();
}
inline void TestConflictingSymbolNames_Data2::clear_data() {
  data_.Clear();
}
inline ::protobuf_unittest::TestConflictingSymbolNames_TestEnum TestConflictingSymbolNames_Data2::data(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestConflictingSymbolNames.Data2.data)
  return static_cast< ::protobuf_unittest::TestConflictingSymbolNames_TestEnum >(data_.Get(index));
}
inline void TestConflictingSymbolNames_Data2::set_data(int index, ::protobuf_unittest::TestConflictingSymbolNames_TestEnum value) {
  assert(::protobuf_unittest::TestConflictingSymbolNames_TestEnum_IsValid(value));
  data_.Set(index, value);
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestConflictingSymbolNames.Data2.data)
}
inline void TestConflictingSymbolNames_Data2::add_data(::protobuf_unittest::TestConflictingSymbolNames_TestEnum value) {
  assert(::protobuf_unittest::TestConflictingSymbolNames_TestEnum_IsValid(value));
  data_.Add(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestConflictingSymbolNames.Data2.data)
}
inline const ::google::protobuf::RepeatedField<int>&
TestConflictingSymbolNames_Data2::data() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestConflictingSymbolNames.Data2.data)
  return data_;
}
inline ::google::protobuf::RepeatedField<int>*
TestConflictingSymbolNames_Data2::mutable_data() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestConflictingSymbolNames.Data2.data)
  return &data_;
}

// -------------------------------------------------------------------

// TestConflictingSymbolNames_Data3

// repeated string data = 1;
inline int TestConflictingSymbolNames_Data3::data_size() const {
  return data_.size();
}
inline void TestConflictingSymbolNames_Data3::clear_data() {
  data_.Clear();
}
inline const ::std::string& TestConflictingSymbolNames_Data3::data(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestConflictingSymbolNames.Data3.data)
  return data_.Get(index);
}
inline ::std::string* TestConflictingSymbolNames_Data3::mutable_data(int index) {
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestConflictingSymbolNames.Data3.data)
  return data_.Mutable(index);
}
inline void TestConflictingSymbolNames_Data3::set_data(int index, const ::std::string& value) {
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestConflictingSymbolNames.Data3.data)
  data_.Mutable(index)->assign(value);
}
#if LANG_CXX11
inline void TestConflictingSymbolNames_Data3::set_data(int index, ::std::string&& value) {
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestConflictingSymbolNames.Data3.data)
  data_.Mutable(index)->assign(std::move(value));
}
#endif
inline void TestConflictingSymbolNames_Data3::set_data(int index, const char* value) {
  GOOGLE_DCHECK(value != NULL);
  data_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:protobuf_unittest.TestConflictingSymbolNames.Data3.data)
}
inline void TestConflictingSymbolNames_Data3::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.TestConflictingSymbolNames.Data3.data)
}
inline ::std::string* TestConflictingSymbolNames_Data3::add_data() {
  // @@protoc_insertion_point(field_add_mutable:protobuf_unittest.TestConflictingSymbolNames.Data3.data)
  return data_.Add();
}
inline void TestConflictingSymbolNames_Data3::add_data(const ::std::string& value) {
  data_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestConflictingSymbolNames.Data3.data)
}
#if LANG_CXX11
inline void TestConflictingSymbolNames_Data3::add_data(::std::string&& value) {
  data_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestConflictingSymbolNames.Data3.data)
}
#endif
inline void TestConflictingSymbolNames_Data3::add_data(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  data_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:protobuf_unittest.TestConflictingSymbolNames.Data3.data)
}
inline void TestConflictingSymbolNames_Data3::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.TestConflictingSymbolNames.Data3.data)
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
TestConflictingSymbolNames_Data3::data() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestConflictingSymbolNames.Data3.data)
  return data_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
TestConflictingSymbolNames_Data3::mutable_data() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestConflictingSymbolNames.Data3.data)
  return &data_;
}

// -------------------------------------------------------------------

// TestConflictingSymbolNames_Data4

// repeated .protobuf_unittest.TestConflictingSymbolNames.Data4 data = 1;
inline int TestConflictingSymbolNames_Data4::data_size() const {
  return data_.size();
}
inline void TestConflictingSymbolNames_Data4::clear_data() {
  data_.Clear();
}
inline ::protobuf_unittest::TestConflictingSymbolNames_Data4* TestConflictingSymbolNames_Data4::mutable_data(int index) {
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestConflictingSymbolNames.Data4.data)
  return data_.Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::TestConflictingSymbolNames_Data4 >*
TestConflictingSymbolNames_Data4::mutable_data() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestConflictingSymbolNames.Data4.data)
  return &data_;
}
inline const ::protobuf_unittest::TestConflictingSymbolNames_Data4& TestConflictingSymbolNames_Data4::data(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestConflictingSymbolNames.Data4.data)
  return data_.Get(index);
}
inline ::protobuf_unittest::TestConflictingSymbolNames_Data4* TestConflictingSymbolNames_Data4::add_data() {
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestConflictingSymbolNames.Data4.data)
  return data_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::TestConflictingSymbolNames_Data4 >&
TestConflictingSymbolNames_Data4::data() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestConflictingSymbolNames.Data4.data)
  return data_;
}

// -------------------------------------------------------------------

// TestConflictingSymbolNames_Data5

// repeated string data = 1 [ctype = STRING_PIECE];
inline int TestConflictingSymbolNames_Data5::data_size() const {
  return data_.size();
}
inline void TestConflictingSymbolNames_Data5::clear_data() {
  data_.Clear();
}
inline const ::std::string& TestConflictingSymbolNames_Data5::data(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestConflictingSymbolNames.Data5.data)
  return data_.Get(index);
}
inline ::std::string* TestConflictingSymbolNames_Data5::mutable_data(int index) {
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestConflictingSymbolNames.Data5.data)
  return data_.Mutable(index);
}
inline void TestConflictingSymbolNames_Data5::set_data(int index, const ::std::string& value) {
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestConflictingSymbolNames.Data5.data)
  data_.Mutable(index)->assign(value);
}
#if LANG_CXX11
inline void TestConflictingSymbolNames_Data5::set_data(int index, ::std::string&& value) {
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestConflictingSymbolNames.Data5.data)
  data_.Mutable(index)->assign(std::move(value));
}
#endif
inline void TestConflictingSymbolNames_Data5::set_data(int index, const char* value) {
  GOOGLE_DCHECK(value != NULL);
  data_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:protobuf_unittest.TestConflictingSymbolNames.Data5.data)
}
inline void TestConflictingSymbolNames_Data5::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.TestConflictingSymbolNames.Data5.data)
}
inline ::std::string* TestConflictingSymbolNames_Data5::add_data() {
  // @@protoc_insertion_point(field_add_mutable:protobuf_unittest.TestConflictingSymbolNames.Data5.data)
  return data_.Add();
}
inline void TestConflictingSymbolNames_Data5::add_data(const ::std::string& value) {
  data_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestConflictingSymbolNames.Data5.data)
}
#if LANG_CXX11
inline void TestConflictingSymbolNames_Data5::add_data(::std::string&& value) {
  data_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestConflictingSymbolNames.Data5.data)
}
#endif
inline void TestConflictingSymbolNames_Data5::add_data(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  data_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:protobuf_unittest.TestConflictingSymbolNames.Data5.data)
}
inline void TestConflictingSymbolNames_Data5::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.TestConflictingSymbolNames.Data5.data)
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
TestConflictingSymbolNames_Data5::data() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestConflictingSymbolNames.Data5.data)
  return data_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
TestConflictingSymbolNames_Data5::mutable_data() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestConflictingSymbolNames.Data5.data)
  return &data_;
}

// -------------------------------------------------------------------

// TestConflictingSymbolNames_Data6

// repeated string data = 1 [ctype = CORD];
inline int TestConflictingSymbolNames_Data6::data_size() const {
  return data_.size();
}
inline void TestConflictingSymbolNames_Data6::clear_data() {
  data_.Clear();
}
inline const ::std::string& TestConflictingSymbolNames_Data6::data(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestConflictingSymbolNames.Data6.data)
  return data_.Get(index);
}
inline ::std::string* TestConflictingSymbolNames_Data6::mutable_data(int index) {
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestConflictingSymbolNames.Data6.data)
  return data_.Mutable(index);
}
inline void TestConflictingSymbolNames_Data6::set_data(int index, const ::std::string& value) {
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestConflictingSymbolNames.Data6.data)
  data_.Mutable(index)->assign(value);
}
#if LANG_CXX11
inline void TestConflictingSymbolNames_Data6::set_data(int index, ::std::string&& value) {
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestConflictingSymbolNames.Data6.data)
  data_.Mutable(index)->assign(std::move(value));
}
#endif
inline void TestConflictingSymbolNames_Data6::set_data(int index, const char* value) {
  GOOGLE_DCHECK(value != NULL);
  data_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:protobuf_unittest.TestConflictingSymbolNames.Data6.data)
}
inline void TestConflictingSymbolNames_Data6::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.TestConflictingSymbolNames.Data6.data)
}
inline ::std::string* TestConflictingSymbolNames_Data6::add_data() {
  // @@protoc_insertion_point(field_add_mutable:protobuf_unittest.TestConflictingSymbolNames.Data6.data)
  return data_.Add();
}
inline void TestConflictingSymbolNames_Data6::add_data(const ::std::string& value) {
  data_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestConflictingSymbolNames.Data6.data)
}
#if LANG_CXX11
inline void TestConflictingSymbolNames_Data6::add_data(::std::string&& value) {
  data_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestConflictingSymbolNames.Data6.data)
}
#endif
inline void TestConflictingSymbolNames_Data6::add_data(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  data_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:protobuf_unittest.TestConflictingSymbolNames.Data6.data)
}
inline void TestConflictingSymbolNames_Data6::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.TestConflictingSymbolNames.Data6.data)
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
TestConflictingSymbolNames_Data6::data() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestConflictingSymbolNames.Data6.data)
  return data_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
TestConflictingSymbolNames_Data6::mutable_data() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestConflictingSymbolNames.Data6.data)
  return &data_;
}

// -------------------------------------------------------------------

// TestConflictingSymbolNames_Cord

// -------------------------------------------------------------------

// TestConflictingSymbolNames_StringPiece

// -------------------------------------------------------------------

// TestConflictingSymbolNames_DO

// -------------------------------------------------------------------

// TestConflictingSymbolNames

// optional int32 input = 1;
inline bool TestConflictingSymbolNames::has_input() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void TestConflictingSymbolNames::set_has_input() {
  _has_bits_[0] |= 0x00000100u;
}
inline void TestConflictingSymbolNames::clear_has_input() {
  _has_bits_[0] &= ~0x00000100u;
}
inline void TestConflictingSymbolNames::clear_input() {
  input_ = 0;
  clear_has_input();
}
inline ::google::protobuf::int32 TestConflictingSymbolNames::input() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestConflictingSymbolNames.input)
  return input_;
}
inline void TestConflictingSymbolNames::set_input(::google::protobuf::int32 value) {
  set_has_input();
  input_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestConflictingSymbolNames.input)
}

// optional int32 output = 2;
inline bool TestConflictingSymbolNames::has_output() const {
  return (_has_bits_[0] & 0x00000200u) != 0;
}
inline void TestConflictingSymbolNames::set_has_output() {
  _has_bits_[0] |= 0x00000200u;
}
inline void TestConflictingSymbolNames::clear_has_output() {
  _has_bits_[0] &= ~0x00000200u;
}
inline void TestConflictingSymbolNames::clear_output() {
  output_ = 0;
  clear_has_output();
}
inline ::google::protobuf::int32 TestConflictingSymbolNames::output() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestConflictingSymbolNames.output)
  return output_;
}
inline void TestConflictingSymbolNames::set_output(::google::protobuf::int32 value) {
  set_has_output();
  output_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestConflictingSymbolNames.output)
}

// optional string length = 3;
inline bool TestConflictingSymbolNames::has_length() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TestConflictingSymbolNames::set_has_length() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TestConflictingSymbolNames::clear_has_length() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TestConflictingSymbolNames::clear_length() {
  length_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_length();
}
inline const ::std::string& TestConflictingSymbolNames::length() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestConflictingSymbolNames.length)
  return length_.GetNoArena();
}
inline void TestConflictingSymbolNames::set_length(const ::std::string& value) {
  set_has_length();
  length_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestConflictingSymbolNames.length)
}
#if LANG_CXX11
inline void TestConflictingSymbolNames::set_length(::std::string&& value) {
  set_has_length();
  length_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:protobuf_unittest.TestConflictingSymbolNames.length)
}
#endif
inline void TestConflictingSymbolNames::set_length(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_length();
  length_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:protobuf_unittest.TestConflictingSymbolNames.length)
}
inline void TestConflictingSymbolNames::set_length(const char* value, size_t size) {
  set_has_length();
  length_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:protobuf_unittest.TestConflictingSymbolNames.length)
}
inline ::std::string* TestConflictingSymbolNames::mutable_length() {
  set_has_length();
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestConflictingSymbolNames.length)
  return length_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* TestConflictingSymbolNames::release_length__() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestConflictingSymbolNames.length)
  if (!has_length()) {
    return NULL;
  }
  clear_has_length();
  return length_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void TestConflictingSymbolNames::set_allocated_length(::std::string* length) {
  if (length != NULL) {
    set_has_length();
  } else {
    clear_has_length();
  }
  length_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), length);
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestConflictingSymbolNames.length)
}

// repeated int32 i = 4;
inline int TestConflictingSymbolNames::i_size() const {
  return i_.size();
}
inline void TestConflictingSymbolNames::clear_i() {
  i_.Clear();
}
inline ::google::protobuf::int32 TestConflictingSymbolNames::i(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestConflictingSymbolNames.i)
  return i_.Get(index);
}
inline void TestConflictingSymbolNames::set_i(int index, ::google::protobuf::int32 value) {
  i_.Set(index, value);
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestConflictingSymbolNames.i)
}
inline void TestConflictingSymbolNames::add_i(::google::protobuf::int32 value) {
  i_.Add(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestConflictingSymbolNames.i)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
TestConflictingSymbolNames::i() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestConflictingSymbolNames.i)
  return i_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
TestConflictingSymbolNames::mutable_i() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestConflictingSymbolNames.i)
  return &i_;
}

// repeated string new_element = 5 [ctype = STRING_PIECE];
inline int TestConflictingSymbolNames::new_element_size() const {
  return new_element_.size();
}
inline void TestConflictingSymbolNames::clear_new_element() {
  new_element_.Clear();
}
inline const ::std::string& TestConflictingSymbolNames::new_element(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestConflictingSymbolNames.new_element)
  return new_element_.Get(index);
}
inline ::std::string* TestConflictingSymbolNames::mutable_new_element(int index) {
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestConflictingSymbolNames.new_element)
  return new_element_.Mutable(index);
}
inline void TestConflictingSymbolNames::set_new_element(int index, const ::std::string& value) {
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestConflictingSymbolNames.new_element)
  new_element_.Mutable(index)->assign(value);
}
#if LANG_CXX11
inline void TestConflictingSymbolNames::set_new_element(int index, ::std::string&& value) {
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestConflictingSymbolNames.new_element)
  new_element_.Mutable(index)->assign(std::move(value));
}
#endif
inline void TestConflictingSymbolNames::set_new_element(int index, const char* value) {
  GOOGLE_DCHECK(value != NULL);
  new_element_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:protobuf_unittest.TestConflictingSymbolNames.new_element)
}
inline void TestConflictingSymbolNames::set_new_element(int index, const char* value, size_t size) {
  new_element_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:protobuf_unittest.TestConflictingSymbolNames.new_element)
}
inline ::std::string* TestConflictingSymbolNames::add_new_element() {
  // @@protoc_insertion_point(field_add_mutable:protobuf_unittest.TestConflictingSymbolNames.new_element)
  return new_element_.Add();
}
inline void TestConflictingSymbolNames::add_new_element(const ::std::string& value) {
  new_element_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestConflictingSymbolNames.new_element)
}
#if LANG_CXX11
inline void TestConflictingSymbolNames::add_new_element(::std::string&& value) {
  new_element_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestConflictingSymbolNames.new_element)
}
#endif
inline void TestConflictingSymbolNames::add_new_element(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  new_element_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:protobuf_unittest.TestConflictingSymbolNames.new_element)
}
inline void TestConflictingSymbolNames::add_new_element(const char* value, size_t size) {
  new_element_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:protobuf_unittest.TestConflictingSymbolNames.new_element)
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
TestConflictingSymbolNames::new_element() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestConflictingSymbolNames.new_element)
  return new_element_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
TestConflictingSymbolNames::mutable_new_element() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestConflictingSymbolNames.new_element)
  return &new_element_;
}

// optional int32 total_size = 6;
inline bool TestConflictingSymbolNames::has_total_size() const {
  return (_has_bits_[0] & 0x00000400u) != 0;
}
inline void TestConflictingSymbolNames::set_has_total_size() {
  _has_bits_[0] |= 0x00000400u;
}
inline void TestConflictingSymbolNames::clear_has_total_size() {
  _has_bits_[0] &= ~0x00000400u;
}
inline void TestConflictingSymbolNames::clear_total_size() {
  total_size_ = 0;
  clear_has_total_size();
}
inline ::google::protobuf::int32 TestConflictingSymbolNames::total_size() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestConflictingSymbolNames.total_size)
  return total_size_;
}
inline void TestConflictingSymbolNames::set_total_size(::google::protobuf::int32 value) {
  set_has_total_size();
  total_size_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestConflictingSymbolNames.total_size)
}

// optional int32 tag = 7;
inline bool TestConflictingSymbolNames::has_tag() const {
  return (_has_bits_[0] & 0x00000800u) != 0;
}
inline void TestConflictingSymbolNames::set_has_tag() {
  _has_bits_[0] |= 0x00000800u;
}
inline void TestConflictingSymbolNames::clear_has_tag() {
  _has_bits_[0] &= ~0x00000800u;
}
inline void TestConflictingSymbolNames::clear_tag() {
  tag_ = 0;
  clear_has_tag();
}
inline ::google::protobuf::int32 TestConflictingSymbolNames::tag() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestConflictingSymbolNames.tag)
  return tag_;
}
inline void TestConflictingSymbolNames::set_tag(::google::protobuf::int32 value) {
  set_has_tag();
  tag_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestConflictingSymbolNames.tag)
}

// optional int32 source = 8;
inline bool TestConflictingSymbolNames::has_source() const {
  return (_has_bits_[0] & 0x00001000u) != 0;
}
inline void TestConflictingSymbolNames::set_has_source() {
  _has_bits_[0] |= 0x00001000u;
}
inline void TestConflictingSymbolNames::clear_has_source() {
  _has_bits_[0] &= ~0x00001000u;
}
inline void TestConflictingSymbolNames::clear_source() {
  source_ = 0;
  clear_has_source();
}
inline ::google::protobuf::int32 TestConflictingSymbolNames::source() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestConflictingSymbolNames.source)
  return source_;
}
inline void TestConflictingSymbolNames::set_source(::google::protobuf::int32 value) {
  set_has_source();
  source_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestConflictingSymbolNames.source)
}

// optional int32 value = 9;
inline bool TestConflictingSymbolNames::has_value() const {
  return (_has_bits_[0] & 0x00002000u) != 0;
}
inline void TestConflictingSymbolNames::set_has_value() {
  _has_bits_[0] |= 0x00002000u;
}
inline void TestConflictingSymbolNames::clear_has_value() {
  _has_bits_[0] &= ~0x00002000u;
}
inline void TestConflictingSymbolNames::clear_value() {
  value_ = 0;
  clear_has_value();
}
inline ::google::protobuf::int32 TestConflictingSymbolNames::value() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestConflictingSymbolNames.value)
  return value_;
}
inline void TestConflictingSymbolNames::set_value(::google::protobuf::int32 value) {
  set_has_value();
  value_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestConflictingSymbolNames.value)
}

// optional int32 file = 10;
inline bool TestConflictingSymbolNames::has_file() const {
  return (_has_bits_[0] & 0x00004000u) != 0;
}
inline void TestConflictingSymbolNames::set_has_file() {
  _has_bits_[0] |= 0x00004000u;
}
inline void TestConflictingSymbolNames::clear_has_file() {
  _has_bits_[0] &= ~0x00004000u;
}
inline void TestConflictingSymbolNames::clear_file() {
  file_ = 0;
  clear_has_file();
}
inline ::google::protobuf::int32 TestConflictingSymbolNames::file() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestConflictingSymbolNames.file)
  return file_;
}
inline void TestConflictingSymbolNames::set_file(::google::protobuf::int32 value) {
  set_has_file();
  file_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestConflictingSymbolNames.file)
}

// optional int32 from = 11;
inline bool TestConflictingSymbolNames::has_from() const {
  return (_has_bits_[0] & 0x00008000u) != 0;
}
inline void TestConflictingSymbolNames::set_has_from() {
  _has_bits_[0] |= 0x00008000u;
}
inline void TestConflictingSymbolNames::clear_has_from() {
  _has_bits_[0] &= ~0x00008000u;
}
inline void TestConflictingSymbolNames::clear_from() {
  from_ = 0;
  clear_has_from();
}
inline ::google::protobuf::int32 TestConflictingSymbolNames::from() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestConflictingSymbolNames.from)
  return from_;
}
inline void TestConflictingSymbolNames::set_from(::google::protobuf::int32 value) {
  set_has_from();
  from_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestConflictingSymbolNames.from)
}

// optional int32 handle_uninterpreted = 12;
inline bool TestConflictingSymbolNames::has_handle_uninterpreted() const {
  return (_has_bits_[0] & 0x00010000u) != 0;
}
inline void TestConflictingSymbolNames::set_has_handle_uninterpreted() {
  _has_bits_[0] |= 0x00010000u;
}
inline void TestConflictingSymbolNames::clear_has_handle_uninterpreted() {
  _has_bits_[0] &= ~0x00010000u;
}
inline void TestConflictingSymbolNames::clear_handle_uninterpreted() {
  handle_uninterpreted_ = 0;
  clear_has_handle_uninterpreted();
}
inline ::google::protobuf::int32 TestConflictingSymbolNames::handle_uninterpreted() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestConflictingSymbolNames.handle_uninterpreted)
  return handle_uninterpreted_;
}
inline void TestConflictingSymbolNames::set_handle_uninterpreted(::google::protobuf::int32 value) {
  set_has_handle_uninterpreted();
  handle_uninterpreted_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestConflictingSymbolNames.handle_uninterpreted)
}

// repeated int32 index = 13;
inline int TestConflictingSymbolNames::index_size() const {
  return index_.size();
}
inline void TestConflictingSymbolNames::clear_index() {
  index_.Clear();
}
inline ::google::protobuf::int32 TestConflictingSymbolNames::index(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestConflictingSymbolNames.index)
  return index_.Get(index);
}
inline void TestConflictingSymbolNames::set_index(int index, ::google::protobuf::int32 value) {
  index_.Set(index, value);
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestConflictingSymbolNames.index)
}
inline void TestConflictingSymbolNames::add_index(::google::protobuf::int32 value) {
  index_.Add(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest.TestConflictingSymbolNames.index)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
TestConflictingSymbolNames::index() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest.TestConflictingSymbolNames.index)
  return index_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
TestConflictingSymbolNames::mutable_index() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest.TestConflictingSymbolNames.index)
  return &index_;
}

// optional int32 controller = 14;
inline bool TestConflictingSymbolNames::has_controller() const {
  return (_has_bits_[0] & 0x00020000u) != 0;
}
inline void TestConflictingSymbolNames::set_has_controller() {
  _has_bits_[0] |= 0x00020000u;
}
inline void TestConflictingSymbolNames::clear_has_controller() {
  _has_bits_[0] &= ~0x00020000u;
}
inline void TestConflictingSymbolNames::clear_controller() {
  controller_ = 0;
  clear_has_controller();
}
inline ::google::protobuf::int32 TestConflictingSymbolNames::controller() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestConflictingSymbolNames.controller)
  return controller_;
}
inline void TestConflictingSymbolNames::set_controller(::google::protobuf::int32 value) {
  set_has_controller();
  controller_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestConflictingSymbolNames.controller)
}

// optional int32 already_here = 15;
inline bool TestConflictingSymbolNames::has_already_here() const {
  return (_has_bits_[0] & 0x00040000u) != 0;
}
inline void TestConflictingSymbolNames::set_has_already_here() {
  _has_bits_[0] |= 0x00040000u;
}
inline void TestConflictingSymbolNames::clear_has_already_here() {
  _has_bits_[0] &= ~0x00040000u;
}
inline void TestConflictingSymbolNames::clear_already_here() {
  already_here_ = 0;
  clear_has_already_here();
}
inline ::google::protobuf::int32 TestConflictingSymbolNames::already_here() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestConflictingSymbolNames.already_here)
  return already_here_;
}
inline void TestConflictingSymbolNames::set_already_here(::google::protobuf::int32 value) {
  set_has_already_here();
  already_here_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestConflictingSymbolNames.already_here)
}

// optional uint32 uint32 = 16;
inline bool TestConflictingSymbolNames::has_uint32() const {
  return (_has_bits_[0] & 0x00080000u) != 0;
}
inline void TestConflictingSymbolNames::set_has_uint32() {
  _has_bits_[0] |= 0x00080000u;
}
inline void TestConflictingSymbolNames::clear_has_uint32() {
  _has_bits_[0] &= ~0x00080000u;
}
inline void TestConflictingSymbolNames::clear_uint32() {
  uint32_ = 0u;
  clear_has_uint32();
}
inline ::google::protobuf::uint32 TestConflictingSymbolNames::uint32() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestConflictingSymbolNames.uint32)
  return uint32_;
}
inline void TestConflictingSymbolNames::set_uint32(::google::protobuf::uint32 value) {
  set_has_uint32();
  uint32_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestConflictingSymbolNames.uint32)
}

// optional uint64 uint64 = 17;
inline bool TestConflictingSymbolNames::has_uint64() const {
  return (_has_bits_[0] & 0x00100000u) != 0;
}
inline void TestConflictingSymbolNames::set_has_uint64() {
  _has_bits_[0] |= 0x00100000u;
}
inline void TestConflictingSymbolNames::clear_has_uint64() {
  _has_bits_[0] &= ~0x00100000u;
}
inline void TestConflictingSymbolNames::clear_uint64() {
  uint64_ = GOOGLE_ULONGLONG(0);
  clear_has_uint64();
}
inline ::google::protobuf::uint64 TestConflictingSymbolNames::uint64() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestConflictingSymbolNames.uint64)
  return uint64_;
}
inline void TestConflictingSymbolNames::set_uint64(::google::protobuf::uint64 value) {
  set_has_uint64();
  uint64_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestConflictingSymbolNames.uint64)
}

// optional string string = 18;
inline bool TestConflictingSymbolNames::has_string() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void TestConflictingSymbolNames::set_has_string() {
  _has_bits_[0] |= 0x00000002u;
}
inline void TestConflictingSymbolNames::clear_has_string() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void TestConflictingSymbolNames::clear_string() {
  string_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_string();
}
inline const ::std::string& TestConflictingSymbolNames::string() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestConflictingSymbolNames.string)
  return string_.GetNoArena();
}
inline void TestConflictingSymbolNames::set_string(const ::std::string& value) {
  set_has_string();
  string_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestConflictingSymbolNames.string)
}
#if LANG_CXX11
inline void TestConflictingSymbolNames::set_string(::std::string&& value) {
  set_has_string();
  string_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:protobuf_unittest.TestConflictingSymbolNames.string)
}
#endif
inline void TestConflictingSymbolNames::set_string(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_string();
  string_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:protobuf_unittest.TestConflictingSymbolNames.string)
}
inline void TestConflictingSymbolNames::set_string(const char* value, size_t size) {
  set_has_string();
  string_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:protobuf_unittest.TestConflictingSymbolNames.string)
}
inline ::std::string* TestConflictingSymbolNames::mutable_string() {
  set_has_string();
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestConflictingSymbolNames.string)
  return string_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* TestConflictingSymbolNames::release_string() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestConflictingSymbolNames.string)
  if (!has_string()) {
    return NULL;
  }
  clear_has_string();
  return string_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void TestConflictingSymbolNames::set_allocated_string(::std::string* string) {
  if (string != NULL) {
    set_has_string();
  } else {
    clear_has_string();
  }
  string_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), string);
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestConflictingSymbolNames.string)
}

// optional int32 memset = 19;
inline bool TestConflictingSymbolNames::has_memset() const {
  return (_has_bits_[0] & 0x00200000u) != 0;
}
inline void TestConflictingSymbolNames::set_has_memset() {
  _has_bits_[0] |= 0x00200000u;
}
inline void TestConflictingSymbolNames::clear_has_memset() {
  _has_bits_[0] &= ~0x00200000u;
}
inline void TestConflictingSymbolNames::clear_memset() {
  memset_ = 0;
  clear_has_memset();
}
inline ::google::protobuf::int32 TestConflictingSymbolNames::memset() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestConflictingSymbolNames.memset)
  return memset_;
}
inline void TestConflictingSymbolNames::set_memset(::google::protobuf::int32 value) {
  set_has_memset();
  memset_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestConflictingSymbolNames.memset)
}

// optional int32 int32 = 20;
inline bool TestConflictingSymbolNames::has_int32() const {
  return (_has_bits_[0] & 0x00400000u) != 0;
}
inline void TestConflictingSymbolNames::set_has_int32() {
  _has_bits_[0] |= 0x00400000u;
}
inline void TestConflictingSymbolNames::clear_has_int32() {
  _has_bits_[0] &= ~0x00400000u;
}
inline void TestConflictingSymbolNames::clear_int32() {
  int32_ = 0;
  clear_has_int32();
}
inline ::google::protobuf::int32 TestConflictingSymbolNames::int32() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestConflictingSymbolNames.int32)
  return int32_;
}
inline void TestConflictingSymbolNames::set_int32(::google::protobuf::int32 value) {
  set_has_int32();
  int32_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestConflictingSymbolNames.int32)
}

// optional int64 int64 = 21;
inline bool TestConflictingSymbolNames::has_int64() const {
  return (_has_bits_[0] & 0x00800000u) != 0;
}
inline void TestConflictingSymbolNames::set_has_int64() {
  _has_bits_[0] |= 0x00800000u;
}
inline void TestConflictingSymbolNames::clear_has_int64() {
  _has_bits_[0] &= ~0x00800000u;
}
inline void TestConflictingSymbolNames::clear_int64() {
  int64_ = GOOGLE_LONGLONG(0);
  clear_has_int64();
}
inline ::google::protobuf::int64 TestConflictingSymbolNames::int64() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestConflictingSymbolNames.int64)
  return int64_;
}
inline void TestConflictingSymbolNames::set_int64(::google::protobuf::int64 value) {
  set_has_int64();
  int64_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestConflictingSymbolNames.int64)
}

// optional uint32 cached_size = 22;
inline bool TestConflictingSymbolNames::has_cached_size() const {
  return (_has_bits_[0] & 0x01000000u) != 0;
}
inline void TestConflictingSymbolNames::set_has_cached_size() {
  _has_bits_[0] |= 0x01000000u;
}
inline void TestConflictingSymbolNames::clear_has_cached_size() {
  _has_bits_[0] &= ~0x01000000u;
}
inline void TestConflictingSymbolNames::clear_cached_size() {
  cached_size_ = 0u;
  clear_has_cached_size();
}
inline ::google::protobuf::uint32 TestConflictingSymbolNames::cached_size() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestConflictingSymbolNames.cached_size)
  return cached_size_;
}
inline void TestConflictingSymbolNames::set_cached_size(::google::protobuf::uint32 value) {
  set_has_cached_size();
  cached_size_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestConflictingSymbolNames.cached_size)
}

// optional uint32 extensions = 23;
inline bool TestConflictingSymbolNames::has_extensions() const {
  return (_has_bits_[0] & 0x02000000u) != 0;
}
inline void TestConflictingSymbolNames::set_has_extensions() {
  _has_bits_[0] |= 0x02000000u;
}
inline void TestConflictingSymbolNames::clear_has_extensions() {
  _has_bits_[0] &= ~0x02000000u;
}
inline void TestConflictingSymbolNames::clear_extensions() {
  extensions_ = 0u;
  clear_has_extensions();
}
inline ::google::protobuf::uint32 TestConflictingSymbolNames::extensions() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestConflictingSymbolNames.extensions)
  return extensions_;
}
inline void TestConflictingSymbolNames::set_extensions(::google::protobuf::uint32 value) {
  set_has_extensions();
  extensions_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestConflictingSymbolNames.extensions)
}

// optional uint32 bit = 24;
inline bool TestConflictingSymbolNames::has_bit() const {
  return (_has_bits_[0] & 0x04000000u) != 0;
}
inline void TestConflictingSymbolNames::set_has_bit() {
  _has_bits_[0] |= 0x04000000u;
}
inline void TestConflictingSymbolNames::clear_has_bit() {
  _has_bits_[0] &= ~0x04000000u;
}
inline void TestConflictingSymbolNames::clear_bit() {
  bit_ = 0u;
  clear_has_bit();
}
inline ::google::protobuf::uint32 TestConflictingSymbolNames::bit() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestConflictingSymbolNames.bit)
  return bit_;
}
inline void TestConflictingSymbolNames::set_bit(::google::protobuf::uint32 value) {
  set_has_bit();
  bit_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestConflictingSymbolNames.bit)
}

// optional uint32 bits = 25;
inline bool TestConflictingSymbolNames::has_bits() const {
  return (_has_bits_[0] & 0x08000000u) != 0;
}
inline void TestConflictingSymbolNames::set_has_bits() {
  _has_bits_[0] |= 0x08000000u;
}
inline void TestConflictingSymbolNames::clear_has_bits() {
  _has_bits_[0] &= ~0x08000000u;
}
inline void TestConflictingSymbolNames::clear_bits() {
  bits_ = 0u;
  clear_has_bits();
}
inline ::google::protobuf::uint32 TestConflictingSymbolNames::bits() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestConflictingSymbolNames.bits)
  return bits_;
}
inline void TestConflictingSymbolNames::set_bits(::google::protobuf::uint32 value) {
  set_has_bits();
  bits_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestConflictingSymbolNames.bits)
}

// optional uint32 offsets = 26;
inline bool TestConflictingSymbolNames::has_offsets() const {
  return (_has_bits_[0] & 0x10000000u) != 0;
}
inline void TestConflictingSymbolNames::set_has_offsets() {
  _has_bits_[0] |= 0x10000000u;
}
inline void TestConflictingSymbolNames::clear_has_offsets() {
  _has_bits_[0] &= ~0x10000000u;
}
inline void TestConflictingSymbolNames::clear_offsets() {
  offsets_ = 0u;
  clear_has_offsets();
}
inline ::google::protobuf::uint32 TestConflictingSymbolNames::offsets() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestConflictingSymbolNames.offsets)
  return offsets_;
}
inline void TestConflictingSymbolNames::set_offsets(::google::protobuf::uint32 value) {
  set_has_offsets();
  offsets_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestConflictingSymbolNames.offsets)
}

// optional uint32 reflection = 27;
inline bool TestConflictingSymbolNames::has_reflection() const {
  return (_has_bits_[0] & 0x20000000u) != 0;
}
inline void TestConflictingSymbolNames::set_has_reflection() {
  _has_bits_[0] |= 0x20000000u;
}
inline void TestConflictingSymbolNames::clear_has_reflection() {
  _has_bits_[0] &= ~0x20000000u;
}
inline void TestConflictingSymbolNames::clear_reflection() {
  reflection_ = 0u;
  clear_has_reflection();
}
inline ::google::protobuf::uint32 TestConflictingSymbolNames::reflection() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestConflictingSymbolNames.reflection)
  return reflection_;
}
inline void TestConflictingSymbolNames::set_reflection(::google::protobuf::uint32 value) {
  set_has_reflection();
  reflection_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestConflictingSymbolNames.reflection)
}

// optional string some_cord = 28 [ctype = CORD];
inline bool TestConflictingSymbolNames::has_some_cord() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void TestConflictingSymbolNames::set_has_some_cord() {
  _has_bits_[0] |= 0x00000004u;
}
inline void TestConflictingSymbolNames::clear_has_some_cord() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void TestConflictingSymbolNames::clear_some_cord() {
  some_cord_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_some_cord();
}
inline const ::std::string& TestConflictingSymbolNames::some_cord() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestConflictingSymbolNames.some_cord)
  return some_cord_.GetNoArena();
}
inline void TestConflictingSymbolNames::set_some_cord(const ::std::string& value) {
  set_has_some_cord();
  some_cord_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestConflictingSymbolNames.some_cord)
}
#if LANG_CXX11
inline void TestConflictingSymbolNames::set_some_cord(::std::string&& value) {
  set_has_some_cord();
  some_cord_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:protobuf_unittest.TestConflictingSymbolNames.some_cord)
}
#endif
inline void TestConflictingSymbolNames::set_some_cord(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_some_cord();
  some_cord_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:protobuf_unittest.TestConflictingSymbolNames.some_cord)
}
inline void TestConflictingSymbolNames::set_some_cord(const char* value, size_t size) {
  set_has_some_cord();
  some_cord_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:protobuf_unittest.TestConflictingSymbolNames.some_cord)
}
inline ::std::string* TestConflictingSymbolNames::mutable_some_cord() {
  set_has_some_cord();
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestConflictingSymbolNames.some_cord)
  return some_cord_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* TestConflictingSymbolNames::release_some_cord() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestConflictingSymbolNames.some_cord)
  if (!has_some_cord()) {
    return NULL;
  }
  clear_has_some_cord();
  return some_cord_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void TestConflictingSymbolNames::set_allocated_some_cord(::std::string* some_cord) {
  if (some_cord != NULL) {
    set_has_some_cord();
  } else {
    clear_has_some_cord();
  }
  some_cord_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), some_cord);
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestConflictingSymbolNames.some_cord)
}

// optional string some_string_piece = 29 [ctype = STRING_PIECE];
inline bool TestConflictingSymbolNames::has_some_string_piece() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void TestConflictingSymbolNames::set_has_some_string_piece() {
  _has_bits_[0] |= 0x00000008u;
}
inline void TestConflictingSymbolNames::clear_has_some_string_piece() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void TestConflictingSymbolNames::clear_some_string_piece() {
  some_string_piece_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_some_string_piece();
}
inline const ::std::string& TestConflictingSymbolNames::some_string_piece() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestConflictingSymbolNames.some_string_piece)
  return some_string_piece_.GetNoArena();
}
inline void TestConflictingSymbolNames::set_some_string_piece(const ::std::string& value) {
  set_has_some_string_piece();
  some_string_piece_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestConflictingSymbolNames.some_string_piece)
}
#if LANG_CXX11
inline void TestConflictingSymbolNames::set_some_string_piece(::std::string&& value) {
  set_has_some_string_piece();
  some_string_piece_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:protobuf_unittest.TestConflictingSymbolNames.some_string_piece)
}
#endif
inline void TestConflictingSymbolNames::set_some_string_piece(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_some_string_piece();
  some_string_piece_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:protobuf_unittest.TestConflictingSymbolNames.some_string_piece)
}
inline void TestConflictingSymbolNames::set_some_string_piece(const char* value, size_t size) {
  set_has_some_string_piece();
  some_string_piece_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:protobuf_unittest.TestConflictingSymbolNames.some_string_piece)
}
inline ::std::string* TestConflictingSymbolNames::mutable_some_string_piece() {
  set_has_some_string_piece();
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestConflictingSymbolNames.some_string_piece)
  return some_string_piece_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* TestConflictingSymbolNames::release_some_string_piece() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestConflictingSymbolNames.some_string_piece)
  if (!has_some_string_piece()) {
    return NULL;
  }
  clear_has_some_string_piece();
  return some_string_piece_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void TestConflictingSymbolNames::set_allocated_some_string_piece(::std::string* some_string_piece) {
  if (some_string_piece != NULL) {
    set_has_some_string_piece();
  } else {
    clear_has_some_string_piece();
  }
  some_string_piece_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), some_string_piece);
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestConflictingSymbolNames.some_string_piece)
}

// optional uint32 int = 30;
inline bool TestConflictingSymbolNames::has_int_() const {
  return (_has_bits_[0] & 0x40000000u) != 0;
}
inline void TestConflictingSymbolNames::set_has_int_() {
  _has_bits_[0] |= 0x40000000u;
}
inline void TestConflictingSymbolNames::clear_has_int_() {
  _has_bits_[0] &= ~0x40000000u;
}
inline void TestConflictingSymbolNames::clear_int_() {
  int__ = 0u;
  clear_has_int_();
}
inline ::google::protobuf::uint32 TestConflictingSymbolNames::int_() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestConflictingSymbolNames.int)
  return int__;
}
inline void TestConflictingSymbolNames::set_int_(::google::protobuf::uint32 value) {
  set_has_int_();
  int__ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestConflictingSymbolNames.int)
}

// optional uint32 friend = 31;
inline bool TestConflictingSymbolNames::has_friend_() const {
  return (_has_bits_[0] & 0x80000000u) != 0;
}
inline void TestConflictingSymbolNames::set_has_friend_() {
  _has_bits_[0] |= 0x80000000u;
}
inline void TestConflictingSymbolNames::clear_has_friend_() {
  _has_bits_[0] &= ~0x80000000u;
}
inline void TestConflictingSymbolNames::clear_friend_() {
  friend__ = 0u;
  clear_has_friend_();
}
inline ::google::protobuf::uint32 TestConflictingSymbolNames::friend_() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestConflictingSymbolNames.friend)
  return friend__;
}
inline void TestConflictingSymbolNames::set_friend_(::google::protobuf::uint32 value) {
  set_has_friend_();
  friend__ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestConflictingSymbolNames.friend)
}

// optional uint32 class = 37;
inline bool TestConflictingSymbolNames::has_class_() const {
  return (_has_bits_[1] & 0x00000004u) != 0;
}
inline void TestConflictingSymbolNames::set_has_class_() {
  _has_bits_[1] |= 0x00000004u;
}
inline void TestConflictingSymbolNames::clear_has_class_() {
  _has_bits_[1] &= ~0x00000004u;
}
inline void TestConflictingSymbolNames::clear_class_() {
  class__ = 0u;
  clear_has_class_();
}
inline ::google::protobuf::uint32 TestConflictingSymbolNames::class_() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestConflictingSymbolNames.class)
  return class__;
}
inline void TestConflictingSymbolNames::set_class_(::google::protobuf::uint32 value) {
  set_has_class_();
  class__ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestConflictingSymbolNames.class)
}

// optional uint32 typedecl = 39;
inline bool TestConflictingSymbolNames::has_typedecl() const {
  return (_has_bits_[1] & 0x00000008u) != 0;
}
inline void TestConflictingSymbolNames::set_has_typedecl() {
  _has_bits_[1] |= 0x00000008u;
}
inline void TestConflictingSymbolNames::clear_has_typedecl() {
  _has_bits_[1] &= ~0x00000008u;
}
inline void TestConflictingSymbolNames::clear_typedecl() {
  typedecl_ = 0u;
  clear_has_typedecl();
}
inline ::google::protobuf::uint32 TestConflictingSymbolNames::typedecl() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestConflictingSymbolNames.typedecl)
  return typedecl_;
}
inline void TestConflictingSymbolNames::set_typedecl(::google::protobuf::uint32 value) {
  set_has_typedecl();
  typedecl_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestConflictingSymbolNames.typedecl)
}

// optional uint32 auto = 40;
inline bool TestConflictingSymbolNames::has_auto_() const {
  return (_has_bits_[1] & 0x00000010u) != 0;
}
inline void TestConflictingSymbolNames::set_has_auto_() {
  _has_bits_[1] |= 0x00000010u;
}
inline void TestConflictingSymbolNames::clear_has_auto_() {
  _has_bits_[1] &= ~0x00000010u;
}
inline void TestConflictingSymbolNames::clear_auto_() {
  auto__ = 0u;
  clear_has_auto_();
}
inline ::google::protobuf::uint32 TestConflictingSymbolNames::auto_() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestConflictingSymbolNames.auto)
  return auto__;
}
inline void TestConflictingSymbolNames::set_auto_(::google::protobuf::uint32 value) {
  set_has_auto_();
  auto__ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestConflictingSymbolNames.auto)
}

// optional .protobuf_unittest.TestConflictingSymbolNames.DO do = 32;
inline bool TestConflictingSymbolNames::has_do_() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void TestConflictingSymbolNames::set_has_do_() {
  _has_bits_[0] |= 0x00000040u;
}
inline void TestConflictingSymbolNames::clear_has_do_() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void TestConflictingSymbolNames::clear_do_() {
  if (do__ != NULL) do__->Clear();
  clear_has_do_();
}
inline const ::protobuf_unittest::TestConflictingSymbolNames_DO& TestConflictingSymbolNames::_internal_do_() const {
  return *do__;
}
inline const ::protobuf_unittest::TestConflictingSymbolNames_DO& TestConflictingSymbolNames::do_() const {
  const ::protobuf_unittest::TestConflictingSymbolNames_DO* p = do__;
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestConflictingSymbolNames.do)
  return p != NULL ? *p : *reinterpret_cast<const ::protobuf_unittest::TestConflictingSymbolNames_DO*>(
      &::protobuf_unittest::_TestConflictingSymbolNames_DO_default_instance_);
}
inline ::protobuf_unittest::TestConflictingSymbolNames_DO* TestConflictingSymbolNames::release_do__() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestConflictingSymbolNames.do)
  clear_has_do_();
  ::protobuf_unittest::TestConflictingSymbolNames_DO* temp = do__;
  do__ = NULL;
  return temp;
}
inline ::protobuf_unittest::TestConflictingSymbolNames_DO* TestConflictingSymbolNames::mutable_do_() {
  set_has_do_();
  if (do__ == NULL) {
    auto* p = CreateMaybeMessage<::protobuf_unittest::TestConflictingSymbolNames_DO>(GetArenaNoVirtual());
    do__ = p;
  }
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestConflictingSymbolNames.do)
  return do__;
}
inline void TestConflictingSymbolNames::set_allocated_do_(::protobuf_unittest::TestConflictingSymbolNames_DO* do_) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete do__;
  }
  if (do_) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      do_ = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, do_, submessage_arena);
    }
    set_has_do_();
  } else {
    clear_has_do_();
  }
  do__ = do_;
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestConflictingSymbolNames.do)
}

// optional int32 field_type = 33;
inline bool TestConflictingSymbolNames::has_field_type() const {
  return (_has_bits_[1] & 0x00000001u) != 0;
}
inline void TestConflictingSymbolNames::set_has_field_type() {
  _has_bits_[1] |= 0x00000001u;
}
inline void TestConflictingSymbolNames::clear_has_field_type() {
  _has_bits_[1] &= ~0x00000001u;
}
inline void TestConflictingSymbolNames::clear_field_type() {
  field_type_ = 0;
  clear_has_field_type();
}
inline ::google::protobuf::int32 TestConflictingSymbolNames::field_type() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestConflictingSymbolNames.field_type)
  return field_type_;
}
inline void TestConflictingSymbolNames::set_field_type(::google::protobuf::int32 value) {
  set_has_field_type();
  field_type_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestConflictingSymbolNames.field_type)
}

// optional bool is_packed = 34;
inline bool TestConflictingSymbolNames::has_is_packed() const {
  return (_has_bits_[1] & 0x00000002u) != 0;
}
inline void TestConflictingSymbolNames::set_has_is_packed() {
  _has_bits_[1] |= 0x00000002u;
}
inline void TestConflictingSymbolNames::clear_has_is_packed() {
  _has_bits_[1] &= ~0x00000002u;
}
inline void TestConflictingSymbolNames::clear_is_packed() {
  is_packed_ = false;
  clear_has_is_packed();
}
inline bool TestConflictingSymbolNames::is_packed() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestConflictingSymbolNames.is_packed)
  return is_packed_;
}
inline void TestConflictingSymbolNames::set_is_packed(bool value) {
  set_has_is_packed();
  is_packed_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestConflictingSymbolNames.is_packed)
}

// optional string release_length = 35;
inline bool TestConflictingSymbolNames::has_release_length() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void TestConflictingSymbolNames::set_has_release_length() {
  _has_bits_[0] |= 0x00000010u;
}
inline void TestConflictingSymbolNames::clear_has_release_length() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void TestConflictingSymbolNames::clear_release_length() {
  release_length_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_release_length();
}
inline const ::std::string& TestConflictingSymbolNames::release_length() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestConflictingSymbolNames.release_length)
  return release_length_.GetNoArena();
}
inline void TestConflictingSymbolNames::set_release_length(const ::std::string& value) {
  set_has_release_length();
  release_length_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestConflictingSymbolNames.release_length)
}
#if LANG_CXX11
inline void TestConflictingSymbolNames::set_release_length(::std::string&& value) {
  set_has_release_length();
  release_length_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:protobuf_unittest.TestConflictingSymbolNames.release_length)
}
#endif
inline void TestConflictingSymbolNames::set_release_length(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_release_length();
  release_length_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:protobuf_unittest.TestConflictingSymbolNames.release_length)
}
inline void TestConflictingSymbolNames::set_release_length(const char* value, size_t size) {
  set_has_release_length();
  release_length_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:protobuf_unittest.TestConflictingSymbolNames.release_length)
}
inline ::std::string* TestConflictingSymbolNames::mutable_release_length() {
  set_has_release_length();
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestConflictingSymbolNames.release_length)
  return release_length_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* TestConflictingSymbolNames::release_release_length() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestConflictingSymbolNames.release_length)
  if (!has_release_length()) {
    return NULL;
  }
  clear_has_release_length();
  return release_length_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void TestConflictingSymbolNames::set_allocated_release_length(::std::string* release_length) {
  if (release_length != NULL) {
    set_has_release_length();
  } else {
    clear_has_release_length();
  }
  release_length_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), release_length);
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestConflictingSymbolNames.release_length)
}

// optional .protobuf_unittest.TestConflictingSymbolNames.DO release_do = 36;
inline bool TestConflictingSymbolNames::has_release_do() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void TestConflictingSymbolNames::set_has_release_do() {
  _has_bits_[0] |= 0x00000080u;
}
inline void TestConflictingSymbolNames::clear_has_release_do() {
  _has_bits_[0] &= ~0x00000080u;
}
inline void TestConflictingSymbolNames::clear_release_do() {
  if (release_do_ != NULL) release_do_->Clear();
  clear_has_release_do();
}
inline const ::protobuf_unittest::TestConflictingSymbolNames_DO& TestConflictingSymbolNames::_internal_release_do() const {
  return *release_do_;
}
inline const ::protobuf_unittest::TestConflictingSymbolNames_DO& TestConflictingSymbolNames::release_do() const {
  const ::protobuf_unittest::TestConflictingSymbolNames_DO* p = release_do_;
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestConflictingSymbolNames.release_do)
  return p != NULL ? *p : *reinterpret_cast<const ::protobuf_unittest::TestConflictingSymbolNames_DO*>(
      &::protobuf_unittest::_TestConflictingSymbolNames_DO_default_instance_);
}
inline ::protobuf_unittest::TestConflictingSymbolNames_DO* TestConflictingSymbolNames::release_release_do() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestConflictingSymbolNames.release_do)
  clear_has_release_do();
  ::protobuf_unittest::TestConflictingSymbolNames_DO* temp = release_do_;
  release_do_ = NULL;
  return temp;
}
inline ::protobuf_unittest::TestConflictingSymbolNames_DO* TestConflictingSymbolNames::mutable_release_do() {
  set_has_release_do();
  if (release_do_ == NULL) {
    auto* p = CreateMaybeMessage<::protobuf_unittest::TestConflictingSymbolNames_DO>(GetArenaNoVirtual());
    release_do_ = p;
  }
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestConflictingSymbolNames.release_do)
  return release_do_;
}
inline void TestConflictingSymbolNames::set_allocated_release_do(::protobuf_unittest::TestConflictingSymbolNames_DO* release_do) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete release_do_;
  }
  if (release_do) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      release_do = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, release_do, submessage_arena);
    }
    set_has_release_do();
  } else {
    clear_has_release_do();
  }
  release_do_ = release_do;
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestConflictingSymbolNames.release_do)
}

// optional string target = 38;
inline bool TestConflictingSymbolNames::has_target() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void TestConflictingSymbolNames::set_has_target() {
  _has_bits_[0] |= 0x00000020u;
}
inline void TestConflictingSymbolNames::clear_has_target() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void TestConflictingSymbolNames::clear_target() {
  target_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_target();
}
inline const ::std::string& TestConflictingSymbolNames::target() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestConflictingSymbolNames.target)
  return target_.GetNoArena();
}
inline void TestConflictingSymbolNames::set_target(const ::std::string& value) {
  set_has_target();
  target_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestConflictingSymbolNames.target)
}
#if LANG_CXX11
inline void TestConflictingSymbolNames::set_target(::std::string&& value) {
  set_has_target();
  target_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:protobuf_unittest.TestConflictingSymbolNames.target)
}
#endif
inline void TestConflictingSymbolNames::set_target(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_target();
  target_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:protobuf_unittest.TestConflictingSymbolNames.target)
}
inline void TestConflictingSymbolNames::set_target(const char* value, size_t size) {
  set_has_target();
  target_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:protobuf_unittest.TestConflictingSymbolNames.target)
}
inline ::std::string* TestConflictingSymbolNames::mutable_target() {
  set_has_target();
  // @@protoc_insertion_point(field_mutable:protobuf_unittest.TestConflictingSymbolNames.target)
  return target_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* TestConflictingSymbolNames::release_target() {
  // @@protoc_insertion_point(field_release:protobuf_unittest.TestConflictingSymbolNames.target)
  if (!has_target()) {
    return NULL;
  }
  clear_has_target();
  return target_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void TestConflictingSymbolNames::set_allocated_target(::std::string* target) {
  if (target != NULL) {
    set_has_target();
  } else {
    clear_has_target();
  }
  target_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), target);
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest.TestConflictingSymbolNames.target)
}

// -------------------------------------------------------------------

// TestConflictingSymbolNamesExtension

// -------------------------------------------------------------------

// TestConflictingEnumNames

// optional .protobuf_unittest.TestConflictingEnumNames.NestedConflictingEnum conflicting_enum = 1;
inline bool TestConflictingEnumNames::has_conflicting_enum() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TestConflictingEnumNames::set_has_conflicting_enum() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TestConflictingEnumNames::clear_has_conflicting_enum() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TestConflictingEnumNames::clear_conflicting_enum() {
  conflicting_enum_ = 1;
  clear_has_conflicting_enum();
}
inline ::protobuf_unittest::TestConflictingEnumNames_NestedConflictingEnum TestConflictingEnumNames::conflicting_enum() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest.TestConflictingEnumNames.conflicting_enum)
  return static_cast< ::protobuf_unittest::TestConflictingEnumNames_NestedConflictingEnum >(conflicting_enum_);
}
inline void TestConflictingEnumNames::set_conflicting_enum(::protobuf_unittest::TestConflictingEnumNames_NestedConflictingEnum value) {
  assert(::protobuf_unittest::TestConflictingEnumNames_NestedConflictingEnum_IsValid(value));
  set_has_conflicting_enum();
  conflicting_enum_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest.TestConflictingEnumNames.conflicting_enum)
}

// -------------------------------------------------------------------

// DummyMessage

// -------------------------------------------------------------------

// Shutdown

// -------------------------------------------------------------------

// TableStruct

#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::TestConflictingSymbolNames_TestEnum> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::protobuf_unittest::TestConflictingSymbolNames_TestEnum>() {
  return ::protobuf_unittest::TestConflictingSymbolNames_TestEnum_descriptor();
}
template <> struct is_proto_enum< ::protobuf_unittest::TestConflictingEnumNames_NestedConflictingEnum> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::protobuf_unittest::TestConflictingEnumNames_NestedConflictingEnum>() {
  return ::protobuf_unittest::TestConflictingEnumNames_NestedConflictingEnum_descriptor();
}
template <> struct is_proto_enum< ::protobuf_unittest::ConflictingEnum> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::protobuf_unittest::ConflictingEnum>() {
  return ::protobuf_unittest::ConflictingEnum_descriptor();
}

}  // namespace protobuf
}  // namespace google

// @@protoc_insertion_point(global_scope)

#endif  // PROTOBUF_INCLUDED_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto
