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

#include <google/protobuf/compiler/cpp/cpp_test_bad_identifiers.pb.h>

#include <algorithm>

#include <google/protobuf/stubs/common.h>
#include <google/protobuf/stubs/port.h>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/wire_format_lite_inl.h>
#include <google/protobuf/descriptor.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/reflection_ops.h>
#include <google/protobuf/wire_format.h>
// This is a temporary google only hack
#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS
#include "third_party/protobuf/version.h"
#endif
// @@protoc_insertion_point(includes)

namespace protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto {
extern PROTOBUF_INTERNAL_EXPORT_protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto ::google::protobuf::internal::SCCInfo<0> scc_info_TestConflictingSymbolNames_DO;
extern PROTOBUF_INTERNAL_EXPORT_protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto ::google::protobuf::internal::SCCInfo<0> scc_info_TestConflictingSymbolNames_Data4;
}  // namespace protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto
namespace protobuf_unittest {
class TestConflictingSymbolNames_BuildDescriptorsDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<TestConflictingSymbolNames_BuildDescriptors>
      _instance;
} _TestConflictingSymbolNames_BuildDescriptors_default_instance_;
class TestConflictingSymbolNames_TypeTraitsDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<TestConflictingSymbolNames_TypeTraits>
      _instance;
} _TestConflictingSymbolNames_TypeTraits_default_instance_;
class TestConflictingSymbolNames_Data1DefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<TestConflictingSymbolNames_Data1>
      _instance;
} _TestConflictingSymbolNames_Data1_default_instance_;
class TestConflictingSymbolNames_Data2DefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<TestConflictingSymbolNames_Data2>
      _instance;
} _TestConflictingSymbolNames_Data2_default_instance_;
class TestConflictingSymbolNames_Data3DefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<TestConflictingSymbolNames_Data3>
      _instance;
} _TestConflictingSymbolNames_Data3_default_instance_;
class TestConflictingSymbolNames_Data4DefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<TestConflictingSymbolNames_Data4>
      _instance;
} _TestConflictingSymbolNames_Data4_default_instance_;
class TestConflictingSymbolNames_Data5DefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<TestConflictingSymbolNames_Data5>
      _instance;
} _TestConflictingSymbolNames_Data5_default_instance_;
class TestConflictingSymbolNames_Data6DefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<TestConflictingSymbolNames_Data6>
      _instance;
} _TestConflictingSymbolNames_Data6_default_instance_;
class TestConflictingSymbolNames_CordDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<TestConflictingSymbolNames_Cord>
      _instance;
} _TestConflictingSymbolNames_Cord_default_instance_;
class TestConflictingSymbolNames_StringPieceDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<TestConflictingSymbolNames_StringPiece>
      _instance;
} _TestConflictingSymbolNames_StringPiece_default_instance_;
class TestConflictingSymbolNames_DODefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<TestConflictingSymbolNames_DO>
      _instance;
} _TestConflictingSymbolNames_DO_default_instance_;
class TestConflictingSymbolNamesDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<TestConflictingSymbolNames>
      _instance;
} _TestConflictingSymbolNames_default_instance_;
class TestConflictingSymbolNamesExtensionDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<TestConflictingSymbolNamesExtension>
      _instance;
} _TestConflictingSymbolNamesExtension_default_instance_;
class TestConflictingEnumNamesDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<TestConflictingEnumNames>
      _instance;
} _TestConflictingEnumNames_default_instance_;
class DummyMessageDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<DummyMessage>
      _instance;
} _DummyMessage_default_instance_;
class ShutdownDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<Shutdown>
      _instance;
} _Shutdown_default_instance_;
class TableStructDefaultTypeInternal {
 public:
  ::google::protobuf::internal::ExplicitlyConstructed<TableStruct>
      _instance;
} _TableStruct_default_instance_;
}  // namespace protobuf_unittest
namespace protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto {
static void InitDefaultsTestConflictingSymbolNames_BuildDescriptors() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::protobuf_unittest::_TestConflictingSymbolNames_BuildDescriptors_default_instance_;
    new (ptr) ::protobuf_unittest::TestConflictingSymbolNames_BuildDescriptors();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::protobuf_unittest::TestConflictingSymbolNames_BuildDescriptors::InitAsDefaultInstance();
}

::google::protobuf::internal::SCCInfo<0> scc_info_TestConflictingSymbolNames_BuildDescriptors =
    {{ATOMIC_VAR_INIT(::google::protobuf::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsTestConflictingSymbolNames_BuildDescriptors}, {}};

static void InitDefaultsTestConflictingSymbolNames_TypeTraits() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::protobuf_unittest::_TestConflictingSymbolNames_TypeTraits_default_instance_;
    new (ptr) ::protobuf_unittest::TestConflictingSymbolNames_TypeTraits();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::protobuf_unittest::TestConflictingSymbolNames_TypeTraits::InitAsDefaultInstance();
}

::google::protobuf::internal::SCCInfo<0> scc_info_TestConflictingSymbolNames_TypeTraits =
    {{ATOMIC_VAR_INIT(::google::protobuf::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsTestConflictingSymbolNames_TypeTraits}, {}};

static void InitDefaultsTestConflictingSymbolNames_Data1() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::protobuf_unittest::_TestConflictingSymbolNames_Data1_default_instance_;
    new (ptr) ::protobuf_unittest::TestConflictingSymbolNames_Data1();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::protobuf_unittest::TestConflictingSymbolNames_Data1::InitAsDefaultInstance();
}

::google::protobuf::internal::SCCInfo<0> scc_info_TestConflictingSymbolNames_Data1 =
    {{ATOMIC_VAR_INIT(::google::protobuf::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsTestConflictingSymbolNames_Data1}, {}};

static void InitDefaultsTestConflictingSymbolNames_Data2() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::protobuf_unittest::_TestConflictingSymbolNames_Data2_default_instance_;
    new (ptr) ::protobuf_unittest::TestConflictingSymbolNames_Data2();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::protobuf_unittest::TestConflictingSymbolNames_Data2::InitAsDefaultInstance();
}

::google::protobuf::internal::SCCInfo<0> scc_info_TestConflictingSymbolNames_Data2 =
    {{ATOMIC_VAR_INIT(::google::protobuf::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsTestConflictingSymbolNames_Data2}, {}};

static void InitDefaultsTestConflictingSymbolNames_Data3() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::protobuf_unittest::_TestConflictingSymbolNames_Data3_default_instance_;
    new (ptr) ::protobuf_unittest::TestConflictingSymbolNames_Data3();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::protobuf_unittest::TestConflictingSymbolNames_Data3::InitAsDefaultInstance();
}

::google::protobuf::internal::SCCInfo<0> scc_info_TestConflictingSymbolNames_Data3 =
    {{ATOMIC_VAR_INIT(::google::protobuf::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsTestConflictingSymbolNames_Data3}, {}};

static void InitDefaultsTestConflictingSymbolNames_Data4() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::protobuf_unittest::_TestConflictingSymbolNames_Data4_default_instance_;
    new (ptr) ::protobuf_unittest::TestConflictingSymbolNames_Data4();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::protobuf_unittest::TestConflictingSymbolNames_Data4::InitAsDefaultInstance();
}

::google::protobuf::internal::SCCInfo<0> scc_info_TestConflictingSymbolNames_Data4 =
    {{ATOMIC_VAR_INIT(::google::protobuf::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsTestConflictingSymbolNames_Data4}, {}};

static void InitDefaultsTestConflictingSymbolNames_Data5() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::protobuf_unittest::_TestConflictingSymbolNames_Data5_default_instance_;
    new (ptr) ::protobuf_unittest::TestConflictingSymbolNames_Data5();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::protobuf_unittest::TestConflictingSymbolNames_Data5::InitAsDefaultInstance();
}

::google::protobuf::internal::SCCInfo<0> scc_info_TestConflictingSymbolNames_Data5 =
    {{ATOMIC_VAR_INIT(::google::protobuf::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsTestConflictingSymbolNames_Data5}, {}};

static void InitDefaultsTestConflictingSymbolNames_Data6() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::protobuf_unittest::_TestConflictingSymbolNames_Data6_default_instance_;
    new (ptr) ::protobuf_unittest::TestConflictingSymbolNames_Data6();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::protobuf_unittest::TestConflictingSymbolNames_Data6::InitAsDefaultInstance();
}

::google::protobuf::internal::SCCInfo<0> scc_info_TestConflictingSymbolNames_Data6 =
    {{ATOMIC_VAR_INIT(::google::protobuf::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsTestConflictingSymbolNames_Data6}, {}};

static void InitDefaultsTestConflictingSymbolNames_Cord() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::protobuf_unittest::_TestConflictingSymbolNames_Cord_default_instance_;
    new (ptr) ::protobuf_unittest::TestConflictingSymbolNames_Cord();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::protobuf_unittest::TestConflictingSymbolNames_Cord::InitAsDefaultInstance();
}

::google::protobuf::internal::SCCInfo<0> scc_info_TestConflictingSymbolNames_Cord =
    {{ATOMIC_VAR_INIT(::google::protobuf::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsTestConflictingSymbolNames_Cord}, {}};

static void InitDefaultsTestConflictingSymbolNames_StringPiece() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::protobuf_unittest::_TestConflictingSymbolNames_StringPiece_default_instance_;
    new (ptr) ::protobuf_unittest::TestConflictingSymbolNames_StringPiece();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::protobuf_unittest::TestConflictingSymbolNames_StringPiece::InitAsDefaultInstance();
}

::google::protobuf::internal::SCCInfo<0> scc_info_TestConflictingSymbolNames_StringPiece =
    {{ATOMIC_VAR_INIT(::google::protobuf::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsTestConflictingSymbolNames_StringPiece}, {}};

static void InitDefaultsTestConflictingSymbolNames_DO() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::protobuf_unittest::_TestConflictingSymbolNames_DO_default_instance_;
    new (ptr) ::protobuf_unittest::TestConflictingSymbolNames_DO();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::protobuf_unittest::TestConflictingSymbolNames_DO::InitAsDefaultInstance();
}

::google::protobuf::internal::SCCInfo<0> scc_info_TestConflictingSymbolNames_DO =
    {{ATOMIC_VAR_INIT(::google::protobuf::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsTestConflictingSymbolNames_DO}, {}};

static void InitDefaultsTestConflictingSymbolNames() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::protobuf_unittest::_TestConflictingSymbolNames_default_instance_;
    new (ptr) ::protobuf_unittest::TestConflictingSymbolNames();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::protobuf_unittest::TestConflictingSymbolNames::InitAsDefaultInstance();
}

::google::protobuf::internal::SCCInfo<1> scc_info_TestConflictingSymbolNames =
    {{ATOMIC_VAR_INIT(::google::protobuf::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsTestConflictingSymbolNames}, {
      &protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::scc_info_TestConflictingSymbolNames_DO.base,}};

static void InitDefaultsTestConflictingSymbolNamesExtension() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::protobuf_unittest::_TestConflictingSymbolNamesExtension_default_instance_;
    new (ptr) ::protobuf_unittest::TestConflictingSymbolNamesExtension();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::protobuf_unittest::TestConflictingSymbolNamesExtension::InitAsDefaultInstance();
}

::google::protobuf::internal::SCCInfo<0> scc_info_TestConflictingSymbolNamesExtension =
    {{ATOMIC_VAR_INIT(::google::protobuf::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsTestConflictingSymbolNamesExtension}, {}};

static void InitDefaultsTestConflictingEnumNames() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::protobuf_unittest::_TestConflictingEnumNames_default_instance_;
    new (ptr) ::protobuf_unittest::TestConflictingEnumNames();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::protobuf_unittest::TestConflictingEnumNames::InitAsDefaultInstance();
}

::google::protobuf::internal::SCCInfo<0> scc_info_TestConflictingEnumNames =
    {{ATOMIC_VAR_INIT(::google::protobuf::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsTestConflictingEnumNames}, {}};

static void InitDefaultsDummyMessage() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::protobuf_unittest::_DummyMessage_default_instance_;
    new (ptr) ::protobuf_unittest::DummyMessage();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::protobuf_unittest::DummyMessage::InitAsDefaultInstance();
}

::google::protobuf::internal::SCCInfo<0> scc_info_DummyMessage =
    {{ATOMIC_VAR_INIT(::google::protobuf::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsDummyMessage}, {}};

static void InitDefaultsShutdown() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::protobuf_unittest::_Shutdown_default_instance_;
    new (ptr) ::protobuf_unittest::Shutdown();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::protobuf_unittest::Shutdown::InitAsDefaultInstance();
}

::google::protobuf::internal::SCCInfo<0> scc_info_Shutdown =
    {{ATOMIC_VAR_INIT(::google::protobuf::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsShutdown}, {}};

static void InitDefaultsTableStruct() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::protobuf_unittest::_TableStruct_default_instance_;
    new (ptr) ::protobuf_unittest::TableStruct();
    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);
  }
  ::protobuf_unittest::TableStruct::InitAsDefaultInstance();
}

::google::protobuf::internal::SCCInfo<0> scc_info_TableStruct =
    {{ATOMIC_VAR_INIT(::google::protobuf::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsTableStruct}, {}};

void InitDefaults() {
  ::google::protobuf::internal::InitSCC(&scc_info_TestConflictingSymbolNames_BuildDescriptors.base);
  ::google::protobuf::internal::InitSCC(&scc_info_TestConflictingSymbolNames_TypeTraits.base);
  ::google::protobuf::internal::InitSCC(&scc_info_TestConflictingSymbolNames_Data1.base);
  ::google::protobuf::internal::InitSCC(&scc_info_TestConflictingSymbolNames_Data2.base);
  ::google::protobuf::internal::InitSCC(&scc_info_TestConflictingSymbolNames_Data3.base);
  ::google::protobuf::internal::InitSCC(&scc_info_TestConflictingSymbolNames_Data4.base);
  ::google::protobuf::internal::InitSCC(&scc_info_TestConflictingSymbolNames_Data5.base);
  ::google::protobuf::internal::InitSCC(&scc_info_TestConflictingSymbolNames_Data6.base);
  ::google::protobuf::internal::InitSCC(&scc_info_TestConflictingSymbolNames_Cord.base);
  ::google::protobuf::internal::InitSCC(&scc_info_TestConflictingSymbolNames_StringPiece.base);
  ::google::protobuf::internal::InitSCC(&scc_info_TestConflictingSymbolNames_DO.base);
  ::google::protobuf::internal::InitSCC(&scc_info_TestConflictingSymbolNames.base);
  ::google::protobuf::internal::InitSCC(&scc_info_TestConflictingSymbolNamesExtension.base);
  ::google::protobuf::internal::InitSCC(&scc_info_TestConflictingEnumNames.base);
  ::google::protobuf::internal::InitSCC(&scc_info_DummyMessage.base);
  ::google::protobuf::internal::InitSCC(&scc_info_Shutdown.base);
  ::google::protobuf::internal::InitSCC(&scc_info_TableStruct.base);
}

::google::protobuf::Metadata file_level_metadata[17];
const ::google::protobuf::EnumDescriptor* file_level_enum_descriptors[3];
const ::google::protobuf::ServiceDescriptor* file_level_service_descriptors[1];

const ::google::protobuf::uint32 TableStruct::offsets[] GOOGLE_PROTOBUF_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = {
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::protobuf_unittest::TestConflictingSymbolNames_BuildDescriptors, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::protobuf_unittest::TestConflictingSymbolNames_BuildDescriptors, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::protobuf_unittest::TestConflictingSymbolNames_TypeTraits, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::protobuf_unittest::TestConflictingSymbolNames_TypeTraits, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::protobuf_unittest::TestConflictingSymbolNames_Data1, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::protobuf_unittest::TestConflictingSymbolNames_Data1, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::protobuf_unittest::TestConflictingSymbolNames_Data1, data_),
  ~0u,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::protobuf_unittest::TestConflictingSymbolNames_Data2, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::protobuf_unittest::TestConflictingSymbolNames_Data2, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::protobuf_unittest::TestConflictingSymbolNames_Data2, data_),
  ~0u,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::protobuf_unittest::TestConflictingSymbolNames_Data3, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::protobuf_unittest::TestConflictingSymbolNames_Data3, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::protobuf_unittest::TestConflictingSymbolNames_Data3, data_),
  ~0u,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::protobuf_unittest::TestConflictingSymbolNames_Data4, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::protobuf_unittest::TestConflictingSymbolNames_Data4, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::protobuf_unittest::TestConflictingSymbolNames_Data4, data_),
  ~0u,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::protobuf_unittest::TestConflictingSymbolNames_Data5, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::protobuf_unittest::TestConflictingSymbolNames_Data5, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::protobuf_unittest::TestConflictingSymbolNames_Data5, data_),
  ~0u,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::protobuf_unittest::TestConflictingSymbolNames_Data6, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::protobuf_unittest::TestConflictingSymbolNames_Data6, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::protobuf_unittest::TestConflictingSymbolNames_Data6, data_),
  ~0u,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::protobuf_unittest::TestConflictingSymbolNames_Cord, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::protobuf_unittest::TestConflictingSymbolNames_Cord, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::protobuf_unittest::TestConflictingSymbolNames_StringPiece, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::protobuf_unittest::TestConflictingSymbolNames_StringPiece, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::protobuf_unittest::TestConflictingSymbolNames_DO, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::protobuf_unittest::TestConflictingSymbolNames_DO, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::protobuf_unittest::TestConflictingSymbolNames, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::protobuf_unittest::TestConflictingSymbolNames, _internal_metadata_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::protobuf_unittest::TestConflictingSymbolNames, _extensions_),
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::protobuf_unittest::TestConflictingSymbolNames, input_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::protobuf_unittest::TestConflictingSymbolNames, output_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::protobuf_unittest::TestConflictingSymbolNames, length_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::protobuf_unittest::TestConflictingSymbolNames, i_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::protobuf_unittest::TestConflictingSymbolNames, new_element_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::protobuf_unittest::TestConflictingSymbolNames, total_size_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::protobuf_unittest::TestConflictingSymbolNames, tag_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::protobuf_unittest::TestConflictingSymbolNames, source_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::protobuf_unittest::TestConflictingSymbolNames, value_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::protobuf_unittest::TestConflictingSymbolNames, file_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::protobuf_unittest::TestConflictingSymbolNames, from_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::protobuf_unittest::TestConflictingSymbolNames, handle_uninterpreted_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::protobuf_unittest::TestConflictingSymbolNames, index_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::protobuf_unittest::TestConflictingSymbolNames, controller_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::protobuf_unittest::TestConflictingSymbolNames, already_here_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::protobuf_unittest::TestConflictingSymbolNames, uint32_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::protobuf_unittest::TestConflictingSymbolNames, uint64_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::protobuf_unittest::TestConflictingSymbolNames, string_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::protobuf_unittest::TestConflictingSymbolNames, memset_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::protobuf_unittest::TestConflictingSymbolNames, int32_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::protobuf_unittest::TestConflictingSymbolNames, int64_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::protobuf_unittest::TestConflictingSymbolNames, cached_size_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::protobuf_unittest::TestConflictingSymbolNames, extensions_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::protobuf_unittest::TestConflictingSymbolNames, bit_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::protobuf_unittest::TestConflictingSymbolNames, bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::protobuf_unittest::TestConflictingSymbolNames, offsets_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::protobuf_unittest::TestConflictingSymbolNames, reflection_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::protobuf_unittest::TestConflictingSymbolNames, some_cord_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::protobuf_unittest::TestConflictingSymbolNames, some_string_piece_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::protobuf_unittest::TestConflictingSymbolNames, int__),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::protobuf_unittest::TestConflictingSymbolNames, friend__),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::protobuf_unittest::TestConflictingSymbolNames, class__),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::protobuf_unittest::TestConflictingSymbolNames, typedecl_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::protobuf_unittest::TestConflictingSymbolNames, auto__),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::protobuf_unittest::TestConflictingSymbolNames, do__),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::protobuf_unittest::TestConflictingSymbolNames, field_type_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::protobuf_unittest::TestConflictingSymbolNames, is_packed_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::protobuf_unittest::TestConflictingSymbolNames, release_length_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::protobuf_unittest::TestConflictingSymbolNames, release_do_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::protobuf_unittest::TestConflictingSymbolNames, target_),
  8,
  9,
  0,
  ~0u,
  ~0u,
  10,
  11,
  12,
  13,
  14,
  15,
  16,
  ~0u,
  17,
  18,
  19,
  20,
  1,
  21,
  22,
  23,
  24,
  25,
  26,
  27,
  28,
  29,
  2,
  3,
  30,
  31,
  34,
  35,
  36,
  6,
  32,
  33,
  4,
  7,
  5,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::protobuf_unittest::TestConflictingSymbolNamesExtension, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::protobuf_unittest::TestConflictingSymbolNamesExtension, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::protobuf_unittest::TestConflictingEnumNames, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::protobuf_unittest::TestConflictingEnumNames, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::protobuf_unittest::TestConflictingEnumNames, conflicting_enum_),
  0,
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::protobuf_unittest::DummyMessage, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::protobuf_unittest::DummyMessage, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::protobuf_unittest::Shutdown, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::protobuf_unittest::Shutdown, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::protobuf_unittest::TableStruct, _has_bits_),
  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::protobuf_unittest::TableStruct, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
};
static const ::google::protobuf::internal::MigrationSchema schemas[] GOOGLE_PROTOBUF_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = {
  { 0, 5, sizeof(::protobuf_unittest::TestConflictingSymbolNames_BuildDescriptors)},
  { 5, 10, sizeof(::protobuf_unittest::TestConflictingSymbolNames_TypeTraits)},
  { 10, 16, sizeof(::protobuf_unittest::TestConflictingSymbolNames_Data1)},
  { 17, 23, sizeof(::protobuf_unittest::TestConflictingSymbolNames_Data2)},
  { 24, 30, sizeof(::protobuf_unittest::TestConflictingSymbolNames_Data3)},
  { 31, 37, sizeof(::protobuf_unittest::TestConflictingSymbolNames_Data4)},
  { 38, 44, sizeof(::protobuf_unittest::TestConflictingSymbolNames_Data5)},
  { 45, 51, sizeof(::protobuf_unittest::TestConflictingSymbolNames_Data6)},
  { 52, 57, sizeof(::protobuf_unittest::TestConflictingSymbolNames_Cord)},
  { 57, 62, sizeof(::protobuf_unittest::TestConflictingSymbolNames_StringPiece)},
  { 62, 67, sizeof(::protobuf_unittest::TestConflictingSymbolNames_DO)},
  { 67, 112, sizeof(::protobuf_unittest::TestConflictingSymbolNames)},
  { 152, 157, sizeof(::protobuf_unittest::TestConflictingSymbolNamesExtension)},
  { 157, 163, sizeof(::protobuf_unittest::TestConflictingEnumNames)},
  { 164, 169, sizeof(::protobuf_unittest::DummyMessage)},
  { 169, 174, sizeof(::protobuf_unittest::Shutdown)},
  { 174, 179, sizeof(::protobuf_unittest::TableStruct)},
};

static ::google::protobuf::Message const * const file_default_instances[] = {
  reinterpret_cast<const ::google::protobuf::Message*>(&::protobuf_unittest::_TestConflictingSymbolNames_BuildDescriptors_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::protobuf_unittest::_TestConflictingSymbolNames_TypeTraits_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::protobuf_unittest::_TestConflictingSymbolNames_Data1_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::protobuf_unittest::_TestConflictingSymbolNames_Data2_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::protobuf_unittest::_TestConflictingSymbolNames_Data3_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::protobuf_unittest::_TestConflictingSymbolNames_Data4_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::protobuf_unittest::_TestConflictingSymbolNames_Data5_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::protobuf_unittest::_TestConflictingSymbolNames_Data6_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::protobuf_unittest::_TestConflictingSymbolNames_Cord_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::protobuf_unittest::_TestConflictingSymbolNames_StringPiece_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::protobuf_unittest::_TestConflictingSymbolNames_DO_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::protobuf_unittest::_TestConflictingSymbolNames_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::protobuf_unittest::_TestConflictingSymbolNamesExtension_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::protobuf_unittest::_TestConflictingEnumNames_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::protobuf_unittest::_DummyMessage_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::protobuf_unittest::_Shutdown_default_instance_),
  reinterpret_cast<const ::google::protobuf::Message*>(&::protobuf_unittest::_TableStruct_default_instance_),
};

void protobuf_AssignDescriptors() {
  AddDescriptors();
  AssignDescriptors(
      "google/protobuf/compiler/cpp/cpp_test_bad_identifiers.proto", schemas, file_default_instances, TableStruct::offsets,
      file_level_metadata, file_level_enum_descriptors, file_level_service_descriptors);
}

void protobuf_AssignDescriptorsOnce() {
  static ::google::protobuf::internal::once_flag once;
  ::google::protobuf::internal::call_once(once, protobuf_AssignDescriptors);
}

void protobuf_RegisterTypes(const ::std::string&) GOOGLE_PROTOBUF_ATTRIBUTE_COLD;
void protobuf_RegisterTypes(const ::std::string&) {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::internal::RegisterAllTypes(file_level_metadata, 17);
}

void AddDescriptorsImpl() {
  InitDefaults();
  static const char descriptor[] GOOGLE_PROTOBUF_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = {
      "\n;google/protobuf/compiler/cpp/cpp_test_"
      "bad_identifiers.proto\022\021protobuf_unittest"
      "\"\234\t\n\032TestConflictingSymbolNames\022\r\n\005input"
      "\030\001 \001(\005\022\016\n\006output\030\002 \001(\005\022\016\n\006length\030\003 \001(\t\022\t"
      "\n\001i\030\004 \003(\005\022\027\n\013new_element\030\005 \003(\tB\002\010\002\022\022\n\nto"
      "tal_size\030\006 \001(\005\022\013\n\003tag\030\007 \001(\005\022\016\n\006source\030\010 "
      "\001(\005\022\r\n\005value\030\t \001(\005\022\014\n\004file\030\n \001(\005\022\014\n\004from"
      "\030\013 \001(\005\022\034\n\024handle_uninterpreted\030\014 \001(\005\022\r\n\005"
      "index\030\r \003(\005\022\022\n\ncontroller\030\016 \001(\005\022\024\n\014alrea"
      "dy_here\030\017 \001(\005\022\016\n\006uint32\030\020 \001(\r\022\016\n\006uint64\030"
      "\021 \001(\004\022\016\n\006string\030\022 \001(\t\022\016\n\006memset\030\023 \001(\005\022\r\n"
      "\005int32\030\024 \001(\005\022\r\n\005int64\030\025 \001(\003\022\023\n\013cached_si"
      "ze\030\026 \001(\r\022\022\n\nextensions\030\027 \001(\r\022\013\n\003bit\030\030 \001("
      "\r\022\014\n\004bits\030\031 \001(\r\022\017\n\007offsets\030\032 \001(\r\022\022\n\nrefl"
      "ection\030\033 \001(\r\022\025\n\tsome_cord\030\034 \001(\tB\002\010\001\022\035\n\021s"
      "ome_string_piece\030\035 \001(\tB\002\010\002\022\013\n\003int\030\036 \001(\r\022"
      "\016\n\006friend\030\037 \001(\r\022\r\n\005class\030% \001(\r\022\020\n\010typede"
      "cl\030\' \001(\r\022\014\n\004auto\030( \001(\r\022<\n\002do\030  \001(\01320.pro"
      "tobuf_unittest.TestConflictingSymbolName"
      "s.DO\022\022\n\nfield_type\030! \001(\005\022\021\n\tis_packed\030\" "
      "\001(\010\022\026\n\016release_length\030# \001(\t\022D\n\nrelease_d"
      "o\030$ \001(\01320.protobuf_unittest.TestConflict"
      "ingSymbolNames.DO\022\016\n\006target\030& \001(\t\032\022\n\020Bui"
      "ldDescriptors\032\014\n\nTypeTraits\032\025\n\005Data1\022\014\n\004"
      "data\030\001 \003(\005\032M\n\005Data2\022D\n\004data\030\001 \003(\01626.prot"
      "obuf_unittest.TestConflictingSymbolNames"
      ".TestEnum\032\025\n\005Data3\022\014\n\004data\030\001 \003(\t\032J\n\005Data"
      "4\022A\n\004data\030\001 \003(\01323.protobuf_unittest.Test"
      "ConflictingSymbolNames.Data4\032\031\n\005Data5\022\020\n"
      "\004data\030\001 \003(\tB\002\010\002\032\031\n\005Data6\022\020\n\004data\030\001 \003(\tB\002"
      "\010\001\032\006\n\004Cord\032\r\n\013StringPiece\032\004\n\002DO\"\023\n\010TestE"
      "num\022\007\n\003FOO\020\000*\t\010\350\007\020\200\200\200\200\002\"w\n#TestConflicti"
      "ngSymbolNamesExtension2P\n\022repeated_int32"
      "_ext\022-.protobuf_unittest.TestConflicting"
      "SymbolNames\030\326\307\336\t \003(\005B\002\020\001\"\303\001\n\030TestConflic"
      "tingEnumNames\022[\n\020conflicting_enum\030\001 \001(\0162"
      "A.protobuf_unittest.TestConflictingEnumN"
      "ames.NestedConflictingEnum\"J\n\025NestedConf"
      "lictingEnum\022\007\n\003and\020\001\022\t\n\005class\020\002\022\007\n\003int\020\003"
      "\022\013\n\007typedef\020\004\022\007\n\003XOR\020\005\"\016\n\014DummyMessage\"\n"
      "\n\010Shutdown\"\r\n\013TableStruct*7\n\017Conflicting"
      "Enum\022\n\n\006NOT_EQ\020\001\022\014\n\010volatile\020\002\022\n\n\006return"
      "\020\0032i\n\032TestConflictingMethodNames\022K\n\007Clos"
      "ure\022\037.protobuf_unittest.DummyMessage\032\037.p"
      "rotobuf_unittest.DummyMessageB\003\200\001\001"
  };
  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
      descriptor, 1794);
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
    "google/protobuf/compiler/cpp/cpp_test_bad_identifiers.proto", &protobuf_RegisterTypes);
}

void AddDescriptors() {
  static ::google::protobuf::internal::once_flag once;
  ::google::protobuf::internal::call_once(once, AddDescriptorsImpl);
}
// Force AddDescriptors() to be called at dynamic initialization time.
struct StaticDescriptorInitializer {
  StaticDescriptorInitializer() {
    AddDescriptors();
  }
} static_descriptor_initializer;
}  // namespace protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto
namespace protobuf_unittest {
const ::google::protobuf::EnumDescriptor* TestConflictingSymbolNames_TestEnum_descriptor() {
  protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::protobuf_AssignDescriptorsOnce();
  return protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::file_level_enum_descriptors[0];
}
bool TestConflictingSymbolNames_TestEnum_IsValid(int value) {
  switch (value) {
    case 0:
      return true;
    default:
      return false;
  }
}

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const TestConflictingSymbolNames_TestEnum TestConflictingSymbolNames::FOO;
const TestConflictingSymbolNames_TestEnum TestConflictingSymbolNames::TestEnum_MIN;
const TestConflictingSymbolNames_TestEnum TestConflictingSymbolNames::TestEnum_MAX;
const int TestConflictingSymbolNames::TestEnum_ARRAYSIZE;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
const ::google::protobuf::EnumDescriptor* TestConflictingEnumNames_NestedConflictingEnum_descriptor() {
  protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::protobuf_AssignDescriptorsOnce();
  return protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::file_level_enum_descriptors[1];
}
bool TestConflictingEnumNames_NestedConflictingEnum_IsValid(int value) {
  switch (value) {
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
      return true;
    default:
      return false;
  }
}

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const TestConflictingEnumNames_NestedConflictingEnum TestConflictingEnumNames::and_;
const TestConflictingEnumNames_NestedConflictingEnum TestConflictingEnumNames::class_;
const TestConflictingEnumNames_NestedConflictingEnum TestConflictingEnumNames::int_;
const TestConflictingEnumNames_NestedConflictingEnum TestConflictingEnumNames::typedef_;
const TestConflictingEnumNames_NestedConflictingEnum TestConflictingEnumNames::XOR;
const TestConflictingEnumNames_NestedConflictingEnum TestConflictingEnumNames::NestedConflictingEnum_MIN;
const TestConflictingEnumNames_NestedConflictingEnum TestConflictingEnumNames::NestedConflictingEnum_MAX;
const int TestConflictingEnumNames::NestedConflictingEnum_ARRAYSIZE;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900
const ::google::protobuf::EnumDescriptor* ConflictingEnum_descriptor() {
  protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::protobuf_AssignDescriptorsOnce();
  return protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::file_level_enum_descriptors[2];
}
bool ConflictingEnum_IsValid(int value) {
  switch (value) {
    case 1:
    case 2:
    case 3:
      return true;
    default:
      return false;
  }
}


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

void TestConflictingSymbolNames_BuildDescriptors::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

TestConflictingSymbolNames_BuildDescriptors::TestConflictingSymbolNames_BuildDescriptors()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  ::google::protobuf::internal::InitSCC(
      &protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::scc_info_TestConflictingSymbolNames_BuildDescriptors.base);
  SharedCtor();
  // @@protoc_insertion_point(constructor:protobuf_unittest.TestConflictingSymbolNames.BuildDescriptors)
}
TestConflictingSymbolNames_BuildDescriptors::TestConflictingSymbolNames_BuildDescriptors(const TestConflictingSymbolNames_BuildDescriptors& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:protobuf_unittest.TestConflictingSymbolNames.BuildDescriptors)
}

void TestConflictingSymbolNames_BuildDescriptors::SharedCtor() {
}

TestConflictingSymbolNames_BuildDescriptors::~TestConflictingSymbolNames_BuildDescriptors() {
  // @@protoc_insertion_point(destructor:protobuf_unittest.TestConflictingSymbolNames.BuildDescriptors)
  SharedDtor();
}

void TestConflictingSymbolNames_BuildDescriptors::SharedDtor() {
}

void TestConflictingSymbolNames_BuildDescriptors::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const ::google::protobuf::Descriptor* TestConflictingSymbolNames_BuildDescriptors::descriptor() {
  ::protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const TestConflictingSymbolNames_BuildDescriptors& TestConflictingSymbolNames_BuildDescriptors::default_instance() {
  ::google::protobuf::internal::InitSCC(&protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::scc_info_TestConflictingSymbolNames_BuildDescriptors.base);
  return *internal_default_instance();
}


void TestConflictingSymbolNames_BuildDescriptors::Clear() {
// @@protoc_insertion_point(message_clear_start:protobuf_unittest.TestConflictingSymbolNames.BuildDescriptors)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool TestConflictingSymbolNames_BuildDescriptors::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:protobuf_unittest.TestConflictingSymbolNames.BuildDescriptors)
  for (;;) {
    ::std::pair<::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
  handle_unusual:
    if (tag == 0) {
      goto success;
    }
    DO_(::google::protobuf::internal::WireFormat::SkipField(
          input, tag, _internal_metadata_.mutable_unknown_fields()));
  }
success:
  // @@protoc_insertion_point(parse_success:protobuf_unittest.TestConflictingSymbolNames.BuildDescriptors)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:protobuf_unittest.TestConflictingSymbolNames.BuildDescriptors)
  return false;
#undef DO_
}

void TestConflictingSymbolNames_BuildDescriptors::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:protobuf_unittest.TestConflictingSymbolNames.BuildDescriptors)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:protobuf_unittest.TestConflictingSymbolNames.BuildDescriptors)
}

::google::protobuf::uint8* TestConflictingSymbolNames_BuildDescriptors::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:protobuf_unittest.TestConflictingSymbolNames.BuildDescriptors)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:protobuf_unittest.TestConflictingSymbolNames.BuildDescriptors)
  return target;
}

size_t TestConflictingSymbolNames_BuildDescriptors::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:protobuf_unittest.TestConflictingSymbolNames.BuildDescriptors)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void TestConflictingSymbolNames_BuildDescriptors::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:protobuf_unittest.TestConflictingSymbolNames.BuildDescriptors)
  GOOGLE_DCHECK_NE(&from, this);
  const TestConflictingSymbolNames_BuildDescriptors* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const TestConflictingSymbolNames_BuildDescriptors>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:protobuf_unittest.TestConflictingSymbolNames.BuildDescriptors)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:protobuf_unittest.TestConflictingSymbolNames.BuildDescriptors)
    MergeFrom(*source);
  }
}

void TestConflictingSymbolNames_BuildDescriptors::MergeFrom(const TestConflictingSymbolNames_BuildDescriptors& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:protobuf_unittest.TestConflictingSymbolNames.BuildDescriptors)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

}

void TestConflictingSymbolNames_BuildDescriptors::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:protobuf_unittest.TestConflictingSymbolNames.BuildDescriptors)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void TestConflictingSymbolNames_BuildDescriptors::CopyFrom(const TestConflictingSymbolNames_BuildDescriptors& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:protobuf_unittest.TestConflictingSymbolNames.BuildDescriptors)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool TestConflictingSymbolNames_BuildDescriptors::IsInitialized() const {
  return true;
}

void TestConflictingSymbolNames_BuildDescriptors::Swap(TestConflictingSymbolNames_BuildDescriptors* other) {
  if (other == this) return;
  InternalSwap(other);
}
void TestConflictingSymbolNames_BuildDescriptors::InternalSwap(TestConflictingSymbolNames_BuildDescriptors* other) {
  using std::swap;
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
}

::google::protobuf::Metadata TestConflictingSymbolNames_BuildDescriptors::GetMetadata() const {
  protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void TestConflictingSymbolNames_TypeTraits::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

TestConflictingSymbolNames_TypeTraits::TestConflictingSymbolNames_TypeTraits()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  ::google::protobuf::internal::InitSCC(
      &protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::scc_info_TestConflictingSymbolNames_TypeTraits.base);
  SharedCtor();
  // @@protoc_insertion_point(constructor:protobuf_unittest.TestConflictingSymbolNames.TypeTraits)
}
TestConflictingSymbolNames_TypeTraits::TestConflictingSymbolNames_TypeTraits(const TestConflictingSymbolNames_TypeTraits& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:protobuf_unittest.TestConflictingSymbolNames.TypeTraits)
}

void TestConflictingSymbolNames_TypeTraits::SharedCtor() {
}

TestConflictingSymbolNames_TypeTraits::~TestConflictingSymbolNames_TypeTraits() {
  // @@protoc_insertion_point(destructor:protobuf_unittest.TestConflictingSymbolNames.TypeTraits)
  SharedDtor();
}

void TestConflictingSymbolNames_TypeTraits::SharedDtor() {
}

void TestConflictingSymbolNames_TypeTraits::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const ::google::protobuf::Descriptor* TestConflictingSymbolNames_TypeTraits::descriptor() {
  ::protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const TestConflictingSymbolNames_TypeTraits& TestConflictingSymbolNames_TypeTraits::default_instance() {
  ::google::protobuf::internal::InitSCC(&protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::scc_info_TestConflictingSymbolNames_TypeTraits.base);
  return *internal_default_instance();
}


void TestConflictingSymbolNames_TypeTraits::Clear() {
// @@protoc_insertion_point(message_clear_start:protobuf_unittest.TestConflictingSymbolNames.TypeTraits)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool TestConflictingSymbolNames_TypeTraits::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:protobuf_unittest.TestConflictingSymbolNames.TypeTraits)
  for (;;) {
    ::std::pair<::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
  handle_unusual:
    if (tag == 0) {
      goto success;
    }
    DO_(::google::protobuf::internal::WireFormat::SkipField(
          input, tag, _internal_metadata_.mutable_unknown_fields()));
  }
success:
  // @@protoc_insertion_point(parse_success:protobuf_unittest.TestConflictingSymbolNames.TypeTraits)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:protobuf_unittest.TestConflictingSymbolNames.TypeTraits)
  return false;
#undef DO_
}

void TestConflictingSymbolNames_TypeTraits::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:protobuf_unittest.TestConflictingSymbolNames.TypeTraits)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:protobuf_unittest.TestConflictingSymbolNames.TypeTraits)
}

::google::protobuf::uint8* TestConflictingSymbolNames_TypeTraits::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:protobuf_unittest.TestConflictingSymbolNames.TypeTraits)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:protobuf_unittest.TestConflictingSymbolNames.TypeTraits)
  return target;
}

size_t TestConflictingSymbolNames_TypeTraits::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:protobuf_unittest.TestConflictingSymbolNames.TypeTraits)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void TestConflictingSymbolNames_TypeTraits::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:protobuf_unittest.TestConflictingSymbolNames.TypeTraits)
  GOOGLE_DCHECK_NE(&from, this);
  const TestConflictingSymbolNames_TypeTraits* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const TestConflictingSymbolNames_TypeTraits>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:protobuf_unittest.TestConflictingSymbolNames.TypeTraits)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:protobuf_unittest.TestConflictingSymbolNames.TypeTraits)
    MergeFrom(*source);
  }
}

void TestConflictingSymbolNames_TypeTraits::MergeFrom(const TestConflictingSymbolNames_TypeTraits& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:protobuf_unittest.TestConflictingSymbolNames.TypeTraits)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

}

void TestConflictingSymbolNames_TypeTraits::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:protobuf_unittest.TestConflictingSymbolNames.TypeTraits)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void TestConflictingSymbolNames_TypeTraits::CopyFrom(const TestConflictingSymbolNames_TypeTraits& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:protobuf_unittest.TestConflictingSymbolNames.TypeTraits)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool TestConflictingSymbolNames_TypeTraits::IsInitialized() const {
  return true;
}

void TestConflictingSymbolNames_TypeTraits::Swap(TestConflictingSymbolNames_TypeTraits* other) {
  if (other == this) return;
  InternalSwap(other);
}
void TestConflictingSymbolNames_TypeTraits::InternalSwap(TestConflictingSymbolNames_TypeTraits* other) {
  using std::swap;
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
}

::google::protobuf::Metadata TestConflictingSymbolNames_TypeTraits::GetMetadata() const {
  protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void TestConflictingSymbolNames_Data1::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int TestConflictingSymbolNames_Data1::kDataFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

TestConflictingSymbolNames_Data1::TestConflictingSymbolNames_Data1()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  ::google::protobuf::internal::InitSCC(
      &protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::scc_info_TestConflictingSymbolNames_Data1.base);
  SharedCtor();
  // @@protoc_insertion_point(constructor:protobuf_unittest.TestConflictingSymbolNames.Data1)
}
TestConflictingSymbolNames_Data1::TestConflictingSymbolNames_Data1(const TestConflictingSymbolNames_Data1& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      data_(from.data_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:protobuf_unittest.TestConflictingSymbolNames.Data1)
}

void TestConflictingSymbolNames_Data1::SharedCtor() {
}

TestConflictingSymbolNames_Data1::~TestConflictingSymbolNames_Data1() {
  // @@protoc_insertion_point(destructor:protobuf_unittest.TestConflictingSymbolNames.Data1)
  SharedDtor();
}

void TestConflictingSymbolNames_Data1::SharedDtor() {
}

void TestConflictingSymbolNames_Data1::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const ::google::protobuf::Descriptor* TestConflictingSymbolNames_Data1::descriptor() {
  ::protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const TestConflictingSymbolNames_Data1& TestConflictingSymbolNames_Data1::default_instance() {
  ::google::protobuf::internal::InitSCC(&protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::scc_info_TestConflictingSymbolNames_Data1.base);
  return *internal_default_instance();
}


void TestConflictingSymbolNames_Data1::Clear() {
// @@protoc_insertion_point(message_clear_start:protobuf_unittest.TestConflictingSymbolNames.Data1)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  data_.Clear();
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool TestConflictingSymbolNames_Data1::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:protobuf_unittest.TestConflictingSymbolNames.Data1)
  for (;;) {
    ::std::pair<::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // repeated int32 data = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 1, 8u, input, this->mutable_data())));
        } else if (
            static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, this->mutable_data())));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:protobuf_unittest.TestConflictingSymbolNames.Data1)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:protobuf_unittest.TestConflictingSymbolNames.Data1)
  return false;
#undef DO_
}

void TestConflictingSymbolNames_Data1::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:protobuf_unittest.TestConflictingSymbolNames.Data1)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated int32 data = 1;
  for (int i = 0, n = this->data_size(); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(
      1, this->data(i), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:protobuf_unittest.TestConflictingSymbolNames.Data1)
}

::google::protobuf::uint8* TestConflictingSymbolNames_Data1::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:protobuf_unittest.TestConflictingSymbolNames.Data1)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated int32 data = 1;
  target = ::google::protobuf::internal::WireFormatLite::
    WriteInt32ToArray(1, this->data_, target);

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:protobuf_unittest.TestConflictingSymbolNames.Data1)
  return target;
}

size_t TestConflictingSymbolNames_Data1::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:protobuf_unittest.TestConflictingSymbolNames.Data1)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  // repeated int32 data = 1;
  {
    size_t data_size = ::google::protobuf::internal::WireFormatLite::
      Int32Size(this->data_);
    total_size += 1 *
                  ::google::protobuf::internal::FromIntSize(this->data_size());
    total_size += data_size;
  }

  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void TestConflictingSymbolNames_Data1::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:protobuf_unittest.TestConflictingSymbolNames.Data1)
  GOOGLE_DCHECK_NE(&from, this);
  const TestConflictingSymbolNames_Data1* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const TestConflictingSymbolNames_Data1>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:protobuf_unittest.TestConflictingSymbolNames.Data1)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:protobuf_unittest.TestConflictingSymbolNames.Data1)
    MergeFrom(*source);
  }
}

void TestConflictingSymbolNames_Data1::MergeFrom(const TestConflictingSymbolNames_Data1& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:protobuf_unittest.TestConflictingSymbolNames.Data1)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  data_.MergeFrom(from.data_);
}

void TestConflictingSymbolNames_Data1::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:protobuf_unittest.TestConflictingSymbolNames.Data1)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void TestConflictingSymbolNames_Data1::CopyFrom(const TestConflictingSymbolNames_Data1& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:protobuf_unittest.TestConflictingSymbolNames.Data1)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool TestConflictingSymbolNames_Data1::IsInitialized() const {
  return true;
}

void TestConflictingSymbolNames_Data1::Swap(TestConflictingSymbolNames_Data1* other) {
  if (other == this) return;
  InternalSwap(other);
}
void TestConflictingSymbolNames_Data1::InternalSwap(TestConflictingSymbolNames_Data1* other) {
  using std::swap;
  data_.InternalSwap(&other->data_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
}

::google::protobuf::Metadata TestConflictingSymbolNames_Data1::GetMetadata() const {
  protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void TestConflictingSymbolNames_Data2::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int TestConflictingSymbolNames_Data2::kDataFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

TestConflictingSymbolNames_Data2::TestConflictingSymbolNames_Data2()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  ::google::protobuf::internal::InitSCC(
      &protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::scc_info_TestConflictingSymbolNames_Data2.base);
  SharedCtor();
  // @@protoc_insertion_point(constructor:protobuf_unittest.TestConflictingSymbolNames.Data2)
}
TestConflictingSymbolNames_Data2::TestConflictingSymbolNames_Data2(const TestConflictingSymbolNames_Data2& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      data_(from.data_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:protobuf_unittest.TestConflictingSymbolNames.Data2)
}

void TestConflictingSymbolNames_Data2::SharedCtor() {
}

TestConflictingSymbolNames_Data2::~TestConflictingSymbolNames_Data2() {
  // @@protoc_insertion_point(destructor:protobuf_unittest.TestConflictingSymbolNames.Data2)
  SharedDtor();
}

void TestConflictingSymbolNames_Data2::SharedDtor() {
}

void TestConflictingSymbolNames_Data2::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const ::google::protobuf::Descriptor* TestConflictingSymbolNames_Data2::descriptor() {
  ::protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const TestConflictingSymbolNames_Data2& TestConflictingSymbolNames_Data2::default_instance() {
  ::google::protobuf::internal::InitSCC(&protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::scc_info_TestConflictingSymbolNames_Data2.base);
  return *internal_default_instance();
}


void TestConflictingSymbolNames_Data2::Clear() {
// @@protoc_insertion_point(message_clear_start:protobuf_unittest.TestConflictingSymbolNames.Data2)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  data_.Clear();
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool TestConflictingSymbolNames_Data2::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:protobuf_unittest.TestConflictingSymbolNames.Data2)
  for (;;) {
    ::std::pair<::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // repeated .protobuf_unittest.TestConflictingSymbolNames.TestEnum data = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::protobuf_unittest::TestConflictingSymbolNames_TestEnum_IsValid(value)) {
            add_data(static_cast< ::protobuf_unittest::TestConflictingSymbolNames_TestEnum >(value));
          } else {
            mutable_unknown_fields()->AddVarint(
                1, static_cast< ::google::protobuf::uint64>(value));
          }
        } else if (
            static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
          DO_((::google::protobuf::internal::WireFormat::ReadPackedEnumPreserveUnknowns(
                 input,
                 1,
                 ::protobuf_unittest::TestConflictingSymbolNames_TestEnum_IsValid,
                 mutable_unknown_fields(),
                 this->mutable_data())));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:protobuf_unittest.TestConflictingSymbolNames.Data2)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:protobuf_unittest.TestConflictingSymbolNames.Data2)
  return false;
#undef DO_
}

void TestConflictingSymbolNames_Data2::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:protobuf_unittest.TestConflictingSymbolNames.Data2)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .protobuf_unittest.TestConflictingSymbolNames.TestEnum data = 1;
  for (int i = 0, n = this->data_size(); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->data(i), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:protobuf_unittest.TestConflictingSymbolNames.Data2)
}

::google::protobuf::uint8* TestConflictingSymbolNames_Data2::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:protobuf_unittest.TestConflictingSymbolNames.Data2)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .protobuf_unittest.TestConflictingSymbolNames.TestEnum data = 1;
  target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
    1, this->data_, target);

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:protobuf_unittest.TestConflictingSymbolNames.Data2)
  return target;
}

size_t TestConflictingSymbolNames_Data2::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:protobuf_unittest.TestConflictingSymbolNames.Data2)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  // repeated .protobuf_unittest.TestConflictingSymbolNames.TestEnum data = 1;
  {
    size_t data_size = 0;
    unsigned int count = static_cast<unsigned int>(this->data_size());for (unsigned int i = 0; i < count; i++) {
      data_size += ::google::protobuf::internal::WireFormatLite::EnumSize(
        this->data(static_cast<int>(i)));
    }
    total_size += (1UL * count) + data_size;
  }

  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void TestConflictingSymbolNames_Data2::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:protobuf_unittest.TestConflictingSymbolNames.Data2)
  GOOGLE_DCHECK_NE(&from, this);
  const TestConflictingSymbolNames_Data2* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const TestConflictingSymbolNames_Data2>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:protobuf_unittest.TestConflictingSymbolNames.Data2)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:protobuf_unittest.TestConflictingSymbolNames.Data2)
    MergeFrom(*source);
  }
}

void TestConflictingSymbolNames_Data2::MergeFrom(const TestConflictingSymbolNames_Data2& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:protobuf_unittest.TestConflictingSymbolNames.Data2)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  data_.MergeFrom(from.data_);
}

void TestConflictingSymbolNames_Data2::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:protobuf_unittest.TestConflictingSymbolNames.Data2)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void TestConflictingSymbolNames_Data2::CopyFrom(const TestConflictingSymbolNames_Data2& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:protobuf_unittest.TestConflictingSymbolNames.Data2)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool TestConflictingSymbolNames_Data2::IsInitialized() const {
  return true;
}

void TestConflictingSymbolNames_Data2::Swap(TestConflictingSymbolNames_Data2* other) {
  if (other == this) return;
  InternalSwap(other);
}
void TestConflictingSymbolNames_Data2::InternalSwap(TestConflictingSymbolNames_Data2* other) {
  using std::swap;
  data_.InternalSwap(&other->data_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
}

::google::protobuf::Metadata TestConflictingSymbolNames_Data2::GetMetadata() const {
  protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void TestConflictingSymbolNames_Data3::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int TestConflictingSymbolNames_Data3::kDataFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

TestConflictingSymbolNames_Data3::TestConflictingSymbolNames_Data3()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  ::google::protobuf::internal::InitSCC(
      &protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::scc_info_TestConflictingSymbolNames_Data3.base);
  SharedCtor();
  // @@protoc_insertion_point(constructor:protobuf_unittest.TestConflictingSymbolNames.Data3)
}
TestConflictingSymbolNames_Data3::TestConflictingSymbolNames_Data3(const TestConflictingSymbolNames_Data3& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      data_(from.data_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:protobuf_unittest.TestConflictingSymbolNames.Data3)
}

void TestConflictingSymbolNames_Data3::SharedCtor() {
}

TestConflictingSymbolNames_Data3::~TestConflictingSymbolNames_Data3() {
  // @@protoc_insertion_point(destructor:protobuf_unittest.TestConflictingSymbolNames.Data3)
  SharedDtor();
}

void TestConflictingSymbolNames_Data3::SharedDtor() {
}

void TestConflictingSymbolNames_Data3::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const ::google::protobuf::Descriptor* TestConflictingSymbolNames_Data3::descriptor() {
  ::protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const TestConflictingSymbolNames_Data3& TestConflictingSymbolNames_Data3::default_instance() {
  ::google::protobuf::internal::InitSCC(&protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::scc_info_TestConflictingSymbolNames_Data3.base);
  return *internal_default_instance();
}


void TestConflictingSymbolNames_Data3::Clear() {
// @@protoc_insertion_point(message_clear_start:protobuf_unittest.TestConflictingSymbolNames.Data3)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  data_.Clear();
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool TestConflictingSymbolNames_Data3::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:protobuf_unittest.TestConflictingSymbolNames.Data3)
  for (;;) {
    ::std::pair<::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // repeated string data = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->add_data()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->data(this->data_size() - 1).data(),
            static_cast<int>(this->data(this->data_size() - 1).length()),
            ::google::protobuf::internal::WireFormat::PARSE,
            "protobuf_unittest.TestConflictingSymbolNames.Data3.data");
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:protobuf_unittest.TestConflictingSymbolNames.Data3)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:protobuf_unittest.TestConflictingSymbolNames.Data3)
  return false;
#undef DO_
}

void TestConflictingSymbolNames_Data3::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:protobuf_unittest.TestConflictingSymbolNames.Data3)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated string data = 1;
  for (int i = 0, n = this->data_size(); i < n; i++) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->data(i).data(), static_cast<int>(this->data(i).length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "protobuf_unittest.TestConflictingSymbolNames.Data3.data");
    ::google::protobuf::internal::WireFormatLite::WriteString(
      1, this->data(i), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:protobuf_unittest.TestConflictingSymbolNames.Data3)
}

::google::protobuf::uint8* TestConflictingSymbolNames_Data3::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:protobuf_unittest.TestConflictingSymbolNames.Data3)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated string data = 1;
  for (int i = 0, n = this->data_size(); i < n; i++) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->data(i).data(), static_cast<int>(this->data(i).length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "protobuf_unittest.TestConflictingSymbolNames.Data3.data");
    target = ::google::protobuf::internal::WireFormatLite::
      WriteStringToArray(1, this->data(i), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:protobuf_unittest.TestConflictingSymbolNames.Data3)
  return target;
}

size_t TestConflictingSymbolNames_Data3::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:protobuf_unittest.TestConflictingSymbolNames.Data3)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  // repeated string data = 1;
  total_size += 1 *
      ::google::protobuf::internal::FromIntSize(this->data_size());
  for (int i = 0, n = this->data_size(); i < n; i++) {
    total_size += ::google::protobuf::internal::WireFormatLite::StringSize(
      this->data(i));
  }

  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void TestConflictingSymbolNames_Data3::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:protobuf_unittest.TestConflictingSymbolNames.Data3)
  GOOGLE_DCHECK_NE(&from, this);
  const TestConflictingSymbolNames_Data3* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const TestConflictingSymbolNames_Data3>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:protobuf_unittest.TestConflictingSymbolNames.Data3)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:protobuf_unittest.TestConflictingSymbolNames.Data3)
    MergeFrom(*source);
  }
}

void TestConflictingSymbolNames_Data3::MergeFrom(const TestConflictingSymbolNames_Data3& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:protobuf_unittest.TestConflictingSymbolNames.Data3)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  data_.MergeFrom(from.data_);
}

void TestConflictingSymbolNames_Data3::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:protobuf_unittest.TestConflictingSymbolNames.Data3)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void TestConflictingSymbolNames_Data3::CopyFrom(const TestConflictingSymbolNames_Data3& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:protobuf_unittest.TestConflictingSymbolNames.Data3)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool TestConflictingSymbolNames_Data3::IsInitialized() const {
  return true;
}

void TestConflictingSymbolNames_Data3::Swap(TestConflictingSymbolNames_Data3* other) {
  if (other == this) return;
  InternalSwap(other);
}
void TestConflictingSymbolNames_Data3::InternalSwap(TestConflictingSymbolNames_Data3* other) {
  using std::swap;
  data_.InternalSwap(CastToBase(&other->data_));
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
}

::google::protobuf::Metadata TestConflictingSymbolNames_Data3::GetMetadata() const {
  protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void TestConflictingSymbolNames_Data4::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int TestConflictingSymbolNames_Data4::kDataFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

TestConflictingSymbolNames_Data4::TestConflictingSymbolNames_Data4()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  ::google::protobuf::internal::InitSCC(
      &protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::scc_info_TestConflictingSymbolNames_Data4.base);
  SharedCtor();
  // @@protoc_insertion_point(constructor:protobuf_unittest.TestConflictingSymbolNames.Data4)
}
TestConflictingSymbolNames_Data4::TestConflictingSymbolNames_Data4(const TestConflictingSymbolNames_Data4& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      data_(from.data_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:protobuf_unittest.TestConflictingSymbolNames.Data4)
}

void TestConflictingSymbolNames_Data4::SharedCtor() {
}

TestConflictingSymbolNames_Data4::~TestConflictingSymbolNames_Data4() {
  // @@protoc_insertion_point(destructor:protobuf_unittest.TestConflictingSymbolNames.Data4)
  SharedDtor();
}

void TestConflictingSymbolNames_Data4::SharedDtor() {
}

void TestConflictingSymbolNames_Data4::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const ::google::protobuf::Descriptor* TestConflictingSymbolNames_Data4::descriptor() {
  ::protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const TestConflictingSymbolNames_Data4& TestConflictingSymbolNames_Data4::default_instance() {
  ::google::protobuf::internal::InitSCC(&protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::scc_info_TestConflictingSymbolNames_Data4.base);
  return *internal_default_instance();
}


void TestConflictingSymbolNames_Data4::Clear() {
// @@protoc_insertion_point(message_clear_start:protobuf_unittest.TestConflictingSymbolNames.Data4)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  data_.Clear();
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool TestConflictingSymbolNames_Data4::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:protobuf_unittest.TestConflictingSymbolNames.Data4)
  for (;;) {
    ::std::pair<::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // repeated .protobuf_unittest.TestConflictingSymbolNames.Data4 data = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
                input, add_data()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:protobuf_unittest.TestConflictingSymbolNames.Data4)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:protobuf_unittest.TestConflictingSymbolNames.Data4)
  return false;
#undef DO_
}

void TestConflictingSymbolNames_Data4::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:protobuf_unittest.TestConflictingSymbolNames.Data4)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .protobuf_unittest.TestConflictingSymbolNames.Data4 data = 1;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->data_size()); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1,
      this->data(static_cast<int>(i)),
      output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:protobuf_unittest.TestConflictingSymbolNames.Data4)
}

::google::protobuf::uint8* TestConflictingSymbolNames_Data4::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:protobuf_unittest.TestConflictingSymbolNames.Data4)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .protobuf_unittest.TestConflictingSymbolNames.Data4 data = 1;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->data_size()); i < n; i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        1, this->data(static_cast<int>(i)), deterministic, target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:protobuf_unittest.TestConflictingSymbolNames.Data4)
  return target;
}

size_t TestConflictingSymbolNames_Data4::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:protobuf_unittest.TestConflictingSymbolNames.Data4)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  // repeated .protobuf_unittest.TestConflictingSymbolNames.Data4 data = 1;
  {
    unsigned int count = static_cast<unsigned int>(this->data_size());
    total_size += 1UL * count;
    for (unsigned int i = 0; i < count; i++) {
      total_size +=
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          this->data(static_cast<int>(i)));
    }
  }

  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void TestConflictingSymbolNames_Data4::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:protobuf_unittest.TestConflictingSymbolNames.Data4)
  GOOGLE_DCHECK_NE(&from, this);
  const TestConflictingSymbolNames_Data4* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const TestConflictingSymbolNames_Data4>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:protobuf_unittest.TestConflictingSymbolNames.Data4)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:protobuf_unittest.TestConflictingSymbolNames.Data4)
    MergeFrom(*source);
  }
}

void TestConflictingSymbolNames_Data4::MergeFrom(const TestConflictingSymbolNames_Data4& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:protobuf_unittest.TestConflictingSymbolNames.Data4)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  data_.MergeFrom(from.data_);
}

void TestConflictingSymbolNames_Data4::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:protobuf_unittest.TestConflictingSymbolNames.Data4)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void TestConflictingSymbolNames_Data4::CopyFrom(const TestConflictingSymbolNames_Data4& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:protobuf_unittest.TestConflictingSymbolNames.Data4)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool TestConflictingSymbolNames_Data4::IsInitialized() const {
  return true;
}

void TestConflictingSymbolNames_Data4::Swap(TestConflictingSymbolNames_Data4* other) {
  if (other == this) return;
  InternalSwap(other);
}
void TestConflictingSymbolNames_Data4::InternalSwap(TestConflictingSymbolNames_Data4* other) {
  using std::swap;
  CastToBase(&data_)->InternalSwap(CastToBase(&other->data_));
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
}

::google::protobuf::Metadata TestConflictingSymbolNames_Data4::GetMetadata() const {
  protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void TestConflictingSymbolNames_Data5::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int TestConflictingSymbolNames_Data5::kDataFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

TestConflictingSymbolNames_Data5::TestConflictingSymbolNames_Data5()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  ::google::protobuf::internal::InitSCC(
      &protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::scc_info_TestConflictingSymbolNames_Data5.base);
  SharedCtor();
  // @@protoc_insertion_point(constructor:protobuf_unittest.TestConflictingSymbolNames.Data5)
}
TestConflictingSymbolNames_Data5::TestConflictingSymbolNames_Data5(const TestConflictingSymbolNames_Data5& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      data_(from.data_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:protobuf_unittest.TestConflictingSymbolNames.Data5)
}

void TestConflictingSymbolNames_Data5::SharedCtor() {
}

TestConflictingSymbolNames_Data5::~TestConflictingSymbolNames_Data5() {
  // @@protoc_insertion_point(destructor:protobuf_unittest.TestConflictingSymbolNames.Data5)
  SharedDtor();
}

void TestConflictingSymbolNames_Data5::SharedDtor() {
}

void TestConflictingSymbolNames_Data5::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const ::google::protobuf::Descriptor* TestConflictingSymbolNames_Data5::descriptor() {
  ::protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const TestConflictingSymbolNames_Data5& TestConflictingSymbolNames_Data5::default_instance() {
  ::google::protobuf::internal::InitSCC(&protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::scc_info_TestConflictingSymbolNames_Data5.base);
  return *internal_default_instance();
}


void TestConflictingSymbolNames_Data5::Clear() {
// @@protoc_insertion_point(message_clear_start:protobuf_unittest.TestConflictingSymbolNames.Data5)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  data_.Clear();
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool TestConflictingSymbolNames_Data5::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:protobuf_unittest.TestConflictingSymbolNames.Data5)
  for (;;) {
    ::std::pair<::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // repeated string data = 1 [ctype = STRING_PIECE];
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->add_data()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->data(this->data_size() - 1).data(),
            static_cast<int>(this->data(this->data_size() - 1).length()),
            ::google::protobuf::internal::WireFormat::PARSE,
            "protobuf_unittest.TestConflictingSymbolNames.Data5.data");
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:protobuf_unittest.TestConflictingSymbolNames.Data5)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:protobuf_unittest.TestConflictingSymbolNames.Data5)
  return false;
#undef DO_
}

void TestConflictingSymbolNames_Data5::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:protobuf_unittest.TestConflictingSymbolNames.Data5)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated string data = 1 [ctype = STRING_PIECE];
  for (int i = 0, n = this->data_size(); i < n; i++) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->data(i).data(), static_cast<int>(this->data(i).length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "protobuf_unittest.TestConflictingSymbolNames.Data5.data");
    ::google::protobuf::internal::WireFormatLite::WriteString(
      1, this->data(i), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:protobuf_unittest.TestConflictingSymbolNames.Data5)
}

::google::protobuf::uint8* TestConflictingSymbolNames_Data5::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:protobuf_unittest.TestConflictingSymbolNames.Data5)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated string data = 1 [ctype = STRING_PIECE];
  for (int i = 0, n = this->data_size(); i < n; i++) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->data(i).data(), static_cast<int>(this->data(i).length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "protobuf_unittest.TestConflictingSymbolNames.Data5.data");
    target = ::google::protobuf::internal::WireFormatLite::
      WriteStringToArray(1, this->data(i), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:protobuf_unittest.TestConflictingSymbolNames.Data5)
  return target;
}

size_t TestConflictingSymbolNames_Data5::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:protobuf_unittest.TestConflictingSymbolNames.Data5)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  // repeated string data = 1 [ctype = STRING_PIECE];
  total_size += 1 *
      ::google::protobuf::internal::FromIntSize(this->data_size());
  for (int i = 0, n = this->data_size(); i < n; i++) {
    total_size += ::google::protobuf::internal::WireFormatLite::StringSize(
      this->data(i));
  }

  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void TestConflictingSymbolNames_Data5::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:protobuf_unittest.TestConflictingSymbolNames.Data5)
  GOOGLE_DCHECK_NE(&from, this);
  const TestConflictingSymbolNames_Data5* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const TestConflictingSymbolNames_Data5>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:protobuf_unittest.TestConflictingSymbolNames.Data5)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:protobuf_unittest.TestConflictingSymbolNames.Data5)
    MergeFrom(*source);
  }
}

void TestConflictingSymbolNames_Data5::MergeFrom(const TestConflictingSymbolNames_Data5& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:protobuf_unittest.TestConflictingSymbolNames.Data5)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  data_.MergeFrom(from.data_);
}

void TestConflictingSymbolNames_Data5::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:protobuf_unittest.TestConflictingSymbolNames.Data5)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void TestConflictingSymbolNames_Data5::CopyFrom(const TestConflictingSymbolNames_Data5& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:protobuf_unittest.TestConflictingSymbolNames.Data5)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool TestConflictingSymbolNames_Data5::IsInitialized() const {
  return true;
}

void TestConflictingSymbolNames_Data5::Swap(TestConflictingSymbolNames_Data5* other) {
  if (other == this) return;
  InternalSwap(other);
}
void TestConflictingSymbolNames_Data5::InternalSwap(TestConflictingSymbolNames_Data5* other) {
  using std::swap;
  data_.InternalSwap(CastToBase(&other->data_));
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
}

::google::protobuf::Metadata TestConflictingSymbolNames_Data5::GetMetadata() const {
  protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void TestConflictingSymbolNames_Data6::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int TestConflictingSymbolNames_Data6::kDataFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

TestConflictingSymbolNames_Data6::TestConflictingSymbolNames_Data6()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  ::google::protobuf::internal::InitSCC(
      &protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::scc_info_TestConflictingSymbolNames_Data6.base);
  SharedCtor();
  // @@protoc_insertion_point(constructor:protobuf_unittest.TestConflictingSymbolNames.Data6)
}
TestConflictingSymbolNames_Data6::TestConflictingSymbolNames_Data6(const TestConflictingSymbolNames_Data6& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      data_(from.data_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:protobuf_unittest.TestConflictingSymbolNames.Data6)
}

void TestConflictingSymbolNames_Data6::SharedCtor() {
}

TestConflictingSymbolNames_Data6::~TestConflictingSymbolNames_Data6() {
  // @@protoc_insertion_point(destructor:protobuf_unittest.TestConflictingSymbolNames.Data6)
  SharedDtor();
}

void TestConflictingSymbolNames_Data6::SharedDtor() {
}

void TestConflictingSymbolNames_Data6::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const ::google::protobuf::Descriptor* TestConflictingSymbolNames_Data6::descriptor() {
  ::protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const TestConflictingSymbolNames_Data6& TestConflictingSymbolNames_Data6::default_instance() {
  ::google::protobuf::internal::InitSCC(&protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::scc_info_TestConflictingSymbolNames_Data6.base);
  return *internal_default_instance();
}


void TestConflictingSymbolNames_Data6::Clear() {
// @@protoc_insertion_point(message_clear_start:protobuf_unittest.TestConflictingSymbolNames.Data6)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  data_.Clear();
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool TestConflictingSymbolNames_Data6::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:protobuf_unittest.TestConflictingSymbolNames.Data6)
  for (;;) {
    ::std::pair<::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // repeated string data = 1 [ctype = CORD];
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->add_data()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->data(this->data_size() - 1).data(),
            static_cast<int>(this->data(this->data_size() - 1).length()),
            ::google::protobuf::internal::WireFormat::PARSE,
            "protobuf_unittest.TestConflictingSymbolNames.Data6.data");
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:protobuf_unittest.TestConflictingSymbolNames.Data6)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:protobuf_unittest.TestConflictingSymbolNames.Data6)
  return false;
#undef DO_
}

void TestConflictingSymbolNames_Data6::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:protobuf_unittest.TestConflictingSymbolNames.Data6)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated string data = 1 [ctype = CORD];
  for (int i = 0, n = this->data_size(); i < n; i++) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->data(i).data(), static_cast<int>(this->data(i).length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "protobuf_unittest.TestConflictingSymbolNames.Data6.data");
    ::google::protobuf::internal::WireFormatLite::WriteString(
      1, this->data(i), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:protobuf_unittest.TestConflictingSymbolNames.Data6)
}

::google::protobuf::uint8* TestConflictingSymbolNames_Data6::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:protobuf_unittest.TestConflictingSymbolNames.Data6)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated string data = 1 [ctype = CORD];
  for (int i = 0, n = this->data_size(); i < n; i++) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->data(i).data(), static_cast<int>(this->data(i).length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "protobuf_unittest.TestConflictingSymbolNames.Data6.data");
    target = ::google::protobuf::internal::WireFormatLite::
      WriteStringToArray(1, this->data(i), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:protobuf_unittest.TestConflictingSymbolNames.Data6)
  return target;
}

size_t TestConflictingSymbolNames_Data6::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:protobuf_unittest.TestConflictingSymbolNames.Data6)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  // repeated string data = 1 [ctype = CORD];
  total_size += 1 *
      ::google::protobuf::internal::FromIntSize(this->data_size());
  for (int i = 0, n = this->data_size(); i < n; i++) {
    total_size += ::google::protobuf::internal::WireFormatLite::StringSize(
      this->data(i));
  }

  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void TestConflictingSymbolNames_Data6::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:protobuf_unittest.TestConflictingSymbolNames.Data6)
  GOOGLE_DCHECK_NE(&from, this);
  const TestConflictingSymbolNames_Data6* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const TestConflictingSymbolNames_Data6>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:protobuf_unittest.TestConflictingSymbolNames.Data6)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:protobuf_unittest.TestConflictingSymbolNames.Data6)
    MergeFrom(*source);
  }
}

void TestConflictingSymbolNames_Data6::MergeFrom(const TestConflictingSymbolNames_Data6& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:protobuf_unittest.TestConflictingSymbolNames.Data6)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  data_.MergeFrom(from.data_);
}

void TestConflictingSymbolNames_Data6::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:protobuf_unittest.TestConflictingSymbolNames.Data6)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void TestConflictingSymbolNames_Data6::CopyFrom(const TestConflictingSymbolNames_Data6& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:protobuf_unittest.TestConflictingSymbolNames.Data6)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool TestConflictingSymbolNames_Data6::IsInitialized() const {
  return true;
}

void TestConflictingSymbolNames_Data6::Swap(TestConflictingSymbolNames_Data6* other) {
  if (other == this) return;
  InternalSwap(other);
}
void TestConflictingSymbolNames_Data6::InternalSwap(TestConflictingSymbolNames_Data6* other) {
  using std::swap;
  data_.InternalSwap(CastToBase(&other->data_));
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
}

::google::protobuf::Metadata TestConflictingSymbolNames_Data6::GetMetadata() const {
  protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void TestConflictingSymbolNames_Cord::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

TestConflictingSymbolNames_Cord::TestConflictingSymbolNames_Cord()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  ::google::protobuf::internal::InitSCC(
      &protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::scc_info_TestConflictingSymbolNames_Cord.base);
  SharedCtor();
  // @@protoc_insertion_point(constructor:protobuf_unittest.TestConflictingSymbolNames.Cord)
}
TestConflictingSymbolNames_Cord::TestConflictingSymbolNames_Cord(const TestConflictingSymbolNames_Cord& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:protobuf_unittest.TestConflictingSymbolNames.Cord)
}

void TestConflictingSymbolNames_Cord::SharedCtor() {
}

TestConflictingSymbolNames_Cord::~TestConflictingSymbolNames_Cord() {
  // @@protoc_insertion_point(destructor:protobuf_unittest.TestConflictingSymbolNames.Cord)
  SharedDtor();
}

void TestConflictingSymbolNames_Cord::SharedDtor() {
}

void TestConflictingSymbolNames_Cord::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const ::google::protobuf::Descriptor* TestConflictingSymbolNames_Cord::descriptor() {
  ::protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const TestConflictingSymbolNames_Cord& TestConflictingSymbolNames_Cord::default_instance() {
  ::google::protobuf::internal::InitSCC(&protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::scc_info_TestConflictingSymbolNames_Cord.base);
  return *internal_default_instance();
}


void TestConflictingSymbolNames_Cord::Clear() {
// @@protoc_insertion_point(message_clear_start:protobuf_unittest.TestConflictingSymbolNames.Cord)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool TestConflictingSymbolNames_Cord::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:protobuf_unittest.TestConflictingSymbolNames.Cord)
  for (;;) {
    ::std::pair<::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
  handle_unusual:
    if (tag == 0) {
      goto success;
    }
    DO_(::google::protobuf::internal::WireFormat::SkipField(
          input, tag, _internal_metadata_.mutable_unknown_fields()));
  }
success:
  // @@protoc_insertion_point(parse_success:protobuf_unittest.TestConflictingSymbolNames.Cord)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:protobuf_unittest.TestConflictingSymbolNames.Cord)
  return false;
#undef DO_
}

void TestConflictingSymbolNames_Cord::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:protobuf_unittest.TestConflictingSymbolNames.Cord)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:protobuf_unittest.TestConflictingSymbolNames.Cord)
}

::google::protobuf::uint8* TestConflictingSymbolNames_Cord::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:protobuf_unittest.TestConflictingSymbolNames.Cord)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:protobuf_unittest.TestConflictingSymbolNames.Cord)
  return target;
}

size_t TestConflictingSymbolNames_Cord::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:protobuf_unittest.TestConflictingSymbolNames.Cord)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void TestConflictingSymbolNames_Cord::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:protobuf_unittest.TestConflictingSymbolNames.Cord)
  GOOGLE_DCHECK_NE(&from, this);
  const TestConflictingSymbolNames_Cord* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const TestConflictingSymbolNames_Cord>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:protobuf_unittest.TestConflictingSymbolNames.Cord)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:protobuf_unittest.TestConflictingSymbolNames.Cord)
    MergeFrom(*source);
  }
}

void TestConflictingSymbolNames_Cord::MergeFrom(const TestConflictingSymbolNames_Cord& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:protobuf_unittest.TestConflictingSymbolNames.Cord)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

}

void TestConflictingSymbolNames_Cord::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:protobuf_unittest.TestConflictingSymbolNames.Cord)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void TestConflictingSymbolNames_Cord::CopyFrom(const TestConflictingSymbolNames_Cord& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:protobuf_unittest.TestConflictingSymbolNames.Cord)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool TestConflictingSymbolNames_Cord::IsInitialized() const {
  return true;
}

void TestConflictingSymbolNames_Cord::Swap(TestConflictingSymbolNames_Cord* other) {
  if (other == this) return;
  InternalSwap(other);
}
void TestConflictingSymbolNames_Cord::InternalSwap(TestConflictingSymbolNames_Cord* other) {
  using std::swap;
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
}

::google::protobuf::Metadata TestConflictingSymbolNames_Cord::GetMetadata() const {
  protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void TestConflictingSymbolNames_StringPiece::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

TestConflictingSymbolNames_StringPiece::TestConflictingSymbolNames_StringPiece()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  ::google::protobuf::internal::InitSCC(
      &protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::scc_info_TestConflictingSymbolNames_StringPiece.base);
  SharedCtor();
  // @@protoc_insertion_point(constructor:protobuf_unittest.TestConflictingSymbolNames.StringPiece)
}
TestConflictingSymbolNames_StringPiece::TestConflictingSymbolNames_StringPiece(const TestConflictingSymbolNames_StringPiece& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:protobuf_unittest.TestConflictingSymbolNames.StringPiece)
}

void TestConflictingSymbolNames_StringPiece::SharedCtor() {
}

TestConflictingSymbolNames_StringPiece::~TestConflictingSymbolNames_StringPiece() {
  // @@protoc_insertion_point(destructor:protobuf_unittest.TestConflictingSymbolNames.StringPiece)
  SharedDtor();
}

void TestConflictingSymbolNames_StringPiece::SharedDtor() {
}

void TestConflictingSymbolNames_StringPiece::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const ::google::protobuf::Descriptor* TestConflictingSymbolNames_StringPiece::descriptor() {
  ::protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const TestConflictingSymbolNames_StringPiece& TestConflictingSymbolNames_StringPiece::default_instance() {
  ::google::protobuf::internal::InitSCC(&protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::scc_info_TestConflictingSymbolNames_StringPiece.base);
  return *internal_default_instance();
}


void TestConflictingSymbolNames_StringPiece::Clear() {
// @@protoc_insertion_point(message_clear_start:protobuf_unittest.TestConflictingSymbolNames.StringPiece)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool TestConflictingSymbolNames_StringPiece::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:protobuf_unittest.TestConflictingSymbolNames.StringPiece)
  for (;;) {
    ::std::pair<::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
  handle_unusual:
    if (tag == 0) {
      goto success;
    }
    DO_(::google::protobuf::internal::WireFormat::SkipField(
          input, tag, _internal_metadata_.mutable_unknown_fields()));
  }
success:
  // @@protoc_insertion_point(parse_success:protobuf_unittest.TestConflictingSymbolNames.StringPiece)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:protobuf_unittest.TestConflictingSymbolNames.StringPiece)
  return false;
#undef DO_
}

void TestConflictingSymbolNames_StringPiece::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:protobuf_unittest.TestConflictingSymbolNames.StringPiece)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:protobuf_unittest.TestConflictingSymbolNames.StringPiece)
}

::google::protobuf::uint8* TestConflictingSymbolNames_StringPiece::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:protobuf_unittest.TestConflictingSymbolNames.StringPiece)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:protobuf_unittest.TestConflictingSymbolNames.StringPiece)
  return target;
}

size_t TestConflictingSymbolNames_StringPiece::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:protobuf_unittest.TestConflictingSymbolNames.StringPiece)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void TestConflictingSymbolNames_StringPiece::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:protobuf_unittest.TestConflictingSymbolNames.StringPiece)
  GOOGLE_DCHECK_NE(&from, this);
  const TestConflictingSymbolNames_StringPiece* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const TestConflictingSymbolNames_StringPiece>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:protobuf_unittest.TestConflictingSymbolNames.StringPiece)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:protobuf_unittest.TestConflictingSymbolNames.StringPiece)
    MergeFrom(*source);
  }
}

void TestConflictingSymbolNames_StringPiece::MergeFrom(const TestConflictingSymbolNames_StringPiece& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:protobuf_unittest.TestConflictingSymbolNames.StringPiece)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

}

void TestConflictingSymbolNames_StringPiece::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:protobuf_unittest.TestConflictingSymbolNames.StringPiece)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void TestConflictingSymbolNames_StringPiece::CopyFrom(const TestConflictingSymbolNames_StringPiece& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:protobuf_unittest.TestConflictingSymbolNames.StringPiece)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool TestConflictingSymbolNames_StringPiece::IsInitialized() const {
  return true;
}

void TestConflictingSymbolNames_StringPiece::Swap(TestConflictingSymbolNames_StringPiece* other) {
  if (other == this) return;
  InternalSwap(other);
}
void TestConflictingSymbolNames_StringPiece::InternalSwap(TestConflictingSymbolNames_StringPiece* other) {
  using std::swap;
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
}

::google::protobuf::Metadata TestConflictingSymbolNames_StringPiece::GetMetadata() const {
  protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void TestConflictingSymbolNames_DO::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

TestConflictingSymbolNames_DO::TestConflictingSymbolNames_DO()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  ::google::protobuf::internal::InitSCC(
      &protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::scc_info_TestConflictingSymbolNames_DO.base);
  SharedCtor();
  // @@protoc_insertion_point(constructor:protobuf_unittest.TestConflictingSymbolNames.DO)
}
TestConflictingSymbolNames_DO::TestConflictingSymbolNames_DO(const TestConflictingSymbolNames_DO& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:protobuf_unittest.TestConflictingSymbolNames.DO)
}

void TestConflictingSymbolNames_DO::SharedCtor() {
}

TestConflictingSymbolNames_DO::~TestConflictingSymbolNames_DO() {
  // @@protoc_insertion_point(destructor:protobuf_unittest.TestConflictingSymbolNames.DO)
  SharedDtor();
}

void TestConflictingSymbolNames_DO::SharedDtor() {
}

void TestConflictingSymbolNames_DO::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const ::google::protobuf::Descriptor* TestConflictingSymbolNames_DO::descriptor() {
  ::protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const TestConflictingSymbolNames_DO& TestConflictingSymbolNames_DO::default_instance() {
  ::google::protobuf::internal::InitSCC(&protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::scc_info_TestConflictingSymbolNames_DO.base);
  return *internal_default_instance();
}


void TestConflictingSymbolNames_DO::Clear() {
// @@protoc_insertion_point(message_clear_start:protobuf_unittest.TestConflictingSymbolNames.DO)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool TestConflictingSymbolNames_DO::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:protobuf_unittest.TestConflictingSymbolNames.DO)
  for (;;) {
    ::std::pair<::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
  handle_unusual:
    if (tag == 0) {
      goto success;
    }
    DO_(::google::protobuf::internal::WireFormat::SkipField(
          input, tag, _internal_metadata_.mutable_unknown_fields()));
  }
success:
  // @@protoc_insertion_point(parse_success:protobuf_unittest.TestConflictingSymbolNames.DO)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:protobuf_unittest.TestConflictingSymbolNames.DO)
  return false;
#undef DO_
}

void TestConflictingSymbolNames_DO::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:protobuf_unittest.TestConflictingSymbolNames.DO)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:protobuf_unittest.TestConflictingSymbolNames.DO)
}

::google::protobuf::uint8* TestConflictingSymbolNames_DO::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:protobuf_unittest.TestConflictingSymbolNames.DO)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:protobuf_unittest.TestConflictingSymbolNames.DO)
  return target;
}

size_t TestConflictingSymbolNames_DO::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:protobuf_unittest.TestConflictingSymbolNames.DO)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void TestConflictingSymbolNames_DO::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:protobuf_unittest.TestConflictingSymbolNames.DO)
  GOOGLE_DCHECK_NE(&from, this);
  const TestConflictingSymbolNames_DO* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const TestConflictingSymbolNames_DO>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:protobuf_unittest.TestConflictingSymbolNames.DO)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:protobuf_unittest.TestConflictingSymbolNames.DO)
    MergeFrom(*source);
  }
}

void TestConflictingSymbolNames_DO::MergeFrom(const TestConflictingSymbolNames_DO& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:protobuf_unittest.TestConflictingSymbolNames.DO)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

}

void TestConflictingSymbolNames_DO::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:protobuf_unittest.TestConflictingSymbolNames.DO)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void TestConflictingSymbolNames_DO::CopyFrom(const TestConflictingSymbolNames_DO& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:protobuf_unittest.TestConflictingSymbolNames.DO)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool TestConflictingSymbolNames_DO::IsInitialized() const {
  return true;
}

void TestConflictingSymbolNames_DO::Swap(TestConflictingSymbolNames_DO* other) {
  if (other == this) return;
  InternalSwap(other);
}
void TestConflictingSymbolNames_DO::InternalSwap(TestConflictingSymbolNames_DO* other) {
  using std::swap;
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
}

::google::protobuf::Metadata TestConflictingSymbolNames_DO::GetMetadata() const {
  protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void TestConflictingSymbolNames::InitAsDefaultInstance() {
  ::protobuf_unittest::_TestConflictingSymbolNames_default_instance_._instance.get_mutable()->do__ = const_cast< ::protobuf_unittest::TestConflictingSymbolNames_DO*>(
      ::protobuf_unittest::TestConflictingSymbolNames_DO::internal_default_instance());
  ::protobuf_unittest::_TestConflictingSymbolNames_default_instance_._instance.get_mutable()->release_do_ = const_cast< ::protobuf_unittest::TestConflictingSymbolNames_DO*>(
      ::protobuf_unittest::TestConflictingSymbolNames_DO::internal_default_instance());
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int TestConflictingSymbolNames::kInputFieldNumber;
const int TestConflictingSymbolNames::kOutputFieldNumber;
const int TestConflictingSymbolNames::kLengthFieldNumber;
const int TestConflictingSymbolNames::kIFieldNumber;
const int TestConflictingSymbolNames::kNewElementFieldNumber;
const int TestConflictingSymbolNames::kTotalSizeFieldNumber;
const int TestConflictingSymbolNames::kTagFieldNumber;
const int TestConflictingSymbolNames::kSourceFieldNumber;
const int TestConflictingSymbolNames::kValueFieldNumber;
const int TestConflictingSymbolNames::kFileFieldNumber;
const int TestConflictingSymbolNames::kFromFieldNumber;
const int TestConflictingSymbolNames::kHandleUninterpretedFieldNumber;
const int TestConflictingSymbolNames::kIndexFieldNumber;
const int TestConflictingSymbolNames::kControllerFieldNumber;
const int TestConflictingSymbolNames::kAlreadyHereFieldNumber;
const int TestConflictingSymbolNames::kUint32FieldNumber;
const int TestConflictingSymbolNames::kUint64FieldNumber;
const int TestConflictingSymbolNames::kStringFieldNumber;
const int TestConflictingSymbolNames::kMemsetFieldNumber;
const int TestConflictingSymbolNames::kInt32FieldNumber;
const int TestConflictingSymbolNames::kInt64FieldNumber;
const int TestConflictingSymbolNames::kCachedSizeFieldNumber;
const int TestConflictingSymbolNames::kExtensionsFieldNumber;
const int TestConflictingSymbolNames::kBitFieldNumber;
const int TestConflictingSymbolNames::kBitsFieldNumber;
const int TestConflictingSymbolNames::kOffsetsFieldNumber;
const int TestConflictingSymbolNames::kReflectionFieldNumber;
const int TestConflictingSymbolNames::kSomeCordFieldNumber;
const int TestConflictingSymbolNames::kSomeStringPieceFieldNumber;
const int TestConflictingSymbolNames::kIntFieldNumber;
const int TestConflictingSymbolNames::kFriendFieldNumber;
const int TestConflictingSymbolNames::kClassFieldNumber;
const int TestConflictingSymbolNames::kTypedeclFieldNumber;
const int TestConflictingSymbolNames::kAutoFieldNumber;
const int TestConflictingSymbolNames::kDoFieldNumber;
const int TestConflictingSymbolNames::kFieldTypeFieldNumber;
const int TestConflictingSymbolNames::kIsPackedFieldNumber;
const int TestConflictingSymbolNames::kReleaseLengthFieldNumber;
const int TestConflictingSymbolNames::kReleaseDoFieldNumber;
const int TestConflictingSymbolNames::kTargetFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

TestConflictingSymbolNames::TestConflictingSymbolNames()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  ::google::protobuf::internal::InitSCC(
      &protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::scc_info_TestConflictingSymbolNames.base);
  SharedCtor();
  // @@protoc_insertion_point(constructor:protobuf_unittest.TestConflictingSymbolNames)
}
TestConflictingSymbolNames::TestConflictingSymbolNames(const TestConflictingSymbolNames& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      i_(from.i_),
      new_element_(from.new_element_),
      index_(from.index_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  _extensions_.MergeFrom(from._extensions_);
  length_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_length()) {
    length_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.length_);
  }
  string_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_string()) {
    string_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.string_);
  }
  some_cord_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_some_cord()) {
    some_cord_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.some_cord_);
  }
  some_string_piece_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_some_string_piece()) {
    some_string_piece_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.some_string_piece_);
  }
  release_length_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_release_length()) {
    release_length_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.release_length_);
  }
  target_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_target()) {
    target_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.target_);
  }
  if (from.has_do_()) {
    do__ = new ::protobuf_unittest::TestConflictingSymbolNames_DO(*from.do__);
  } else {
    do__ = NULL;
  }
  if (from.has_release_do()) {
    release_do_ = new ::protobuf_unittest::TestConflictingSymbolNames_DO(*from.release_do_);
  } else {
    release_do_ = NULL;
  }
  ::memcpy(&input_, &from.input_,
    static_cast<size_t>(reinterpret_cast<char*>(&auto__) -
    reinterpret_cast<char*>(&input_)) + sizeof(auto__));
  // @@protoc_insertion_point(copy_constructor:protobuf_unittest.TestConflictingSymbolNames)
}

void TestConflictingSymbolNames::SharedCtor() {
  length_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  string_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  some_cord_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  some_string_piece_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  release_length_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  target_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(&do__, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&auto__) -
      reinterpret_cast<char*>(&do__)) + sizeof(auto__));
}

TestConflictingSymbolNames::~TestConflictingSymbolNames() {
  // @@protoc_insertion_point(destructor:protobuf_unittest.TestConflictingSymbolNames)
  SharedDtor();
}

void TestConflictingSymbolNames::SharedDtor() {
  length_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  string_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  some_cord_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  some_string_piece_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  release_length_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  target_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (this != internal_default_instance()) delete do__;
  if (this != internal_default_instance()) delete release_do_;
}

void TestConflictingSymbolNames::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const ::google::protobuf::Descriptor* TestConflictingSymbolNames::descriptor() {
  ::protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const TestConflictingSymbolNames& TestConflictingSymbolNames::default_instance() {
  ::google::protobuf::internal::InitSCC(&protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::scc_info_TestConflictingSymbolNames.base);
  return *internal_default_instance();
}


void TestConflictingSymbolNames::Clear() {
// @@protoc_insertion_point(message_clear_start:protobuf_unittest.TestConflictingSymbolNames)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _extensions_.Clear();
  i_.Clear();
  new_element_.Clear();
  index_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 255u) {
    if (cached_has_bits & 0x00000001u) {
      length_.ClearNonDefaultToEmptyNoArena();
    }
    if (cached_has_bits & 0x00000002u) {
      string_.ClearNonDefaultToEmptyNoArena();
    }
    if (cached_has_bits & 0x00000004u) {
      some_cord_.ClearNonDefaultToEmptyNoArena();
    }
    if (cached_has_bits & 0x00000008u) {
      some_string_piece_.ClearNonDefaultToEmptyNoArena();
    }
    if (cached_has_bits & 0x00000010u) {
      release_length_.ClearNonDefaultToEmptyNoArena();
    }
    if (cached_has_bits & 0x00000020u) {
      target_.ClearNonDefaultToEmptyNoArena();
    }
    if (cached_has_bits & 0x00000040u) {
      GOOGLE_DCHECK(do__ != NULL);
      do__->Clear();
    }
    if (cached_has_bits & 0x00000080u) {
      GOOGLE_DCHECK(release_do_ != NULL);
      release_do_->Clear();
    }
  }
  if (cached_has_bits & 65280u) {
    ::memset(&input_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&from_) -
        reinterpret_cast<char*>(&input_)) + sizeof(from_));
  }
  if (cached_has_bits & 16711680u) {
    ::memset(&handle_uninterpreted_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&int64_) -
        reinterpret_cast<char*>(&handle_uninterpreted_)) + sizeof(int64_));
  }
  if (cached_has_bits & 4278190080u) {
    ::memset(&cached_size_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&friend__) -
        reinterpret_cast<char*>(&cached_size_)) + sizeof(friend__));
  }
  cached_has_bits = _has_bits_[1];
  if (cached_has_bits & 31u) {
    ::memset(&field_type_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&auto__) -
        reinterpret_cast<char*>(&field_type_)) + sizeof(auto__));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool TestConflictingSymbolNames::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:protobuf_unittest.TestConflictingSymbolNames)
  for (;;) {
    ::std::pair<::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(16383u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional int32 input = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) {
          set_has_input();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &input_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 output = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) {
          set_has_output();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &output_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional string length = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(26u /* 26 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_length()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->length().data(), static_cast<int>(this->length().length()),
            ::google::protobuf::internal::WireFormat::PARSE,
            "protobuf_unittest.TestConflictingSymbolNames.length");
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated int32 i = 4;
      case 4: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(32u /* 32 & 0xFF */)) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 1, 32u, input, this->mutable_i())));
        } else if (
            static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(34u /* 34 & 0xFF */)) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, this->mutable_i())));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated string new_element = 5 [ctype = STRING_PIECE];
      case 5: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(42u /* 42 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->add_new_element()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->new_element(this->new_element_size() - 1).data(),
            static_cast<int>(this->new_element(this->new_element_size() - 1).length()),
            ::google::protobuf::internal::WireFormat::PARSE,
            "protobuf_unittest.TestConflictingSymbolNames.new_element");
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 total_size = 6;
      case 6: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(48u /* 48 & 0xFF */)) {
          set_has_total_size();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &total_size_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 tag = 7;
      case 7: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(56u /* 56 & 0xFF */)) {
          set_has_tag();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &tag_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 source = 8;
      case 8: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(64u /* 64 & 0xFF */)) {
          set_has_source();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &source_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 value = 9;
      case 9: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(72u /* 72 & 0xFF */)) {
          set_has_value();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &value_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 file = 10;
      case 10: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(80u /* 80 & 0xFF */)) {
          set_has_file();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &file_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 from = 11;
      case 11: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(88u /* 88 & 0xFF */)) {
          set_has_from();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &from_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 handle_uninterpreted = 12;
      case 12: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(96u /* 96 & 0xFF */)) {
          set_has_handle_uninterpreted();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &handle_uninterpreted_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // repeated int32 index = 13;
      case 13: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(104u /* 104 & 0xFF */)) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 1, 104u, input, this->mutable_index())));
        } else if (
            static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(106u /* 106 & 0xFF */)) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, this->mutable_index())));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 controller = 14;
      case 14: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(112u /* 112 & 0xFF */)) {
          set_has_controller();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &controller_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 already_here = 15;
      case 15: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(120u /* 120 & 0xFF */)) {
          set_has_already_here();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &already_here_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 uint32 = 16;
      case 16: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(128u /* 128 & 0xFF */)) {
          set_has_uint32();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &uint32_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint64 uint64 = 17;
      case 17: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(136u /* 136 & 0xFF */)) {
          set_has_uint64();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
                 input, &uint64_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional string string = 18;
      case 18: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(146u /* 146 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_string()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->string().data(), static_cast<int>(this->string().length()),
            ::google::protobuf::internal::WireFormat::PARSE,
            "protobuf_unittest.TestConflictingSymbolNames.string");
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 memset = 19;
      case 19: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(152u /* 152 & 0xFF */)) {
          set_has_memset();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &memset_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 int32 = 20;
      case 20: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(160u /* 160 & 0xFF */)) {
          set_has_int32();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &int32_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int64 int64 = 21;
      case 21: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(168u /* 168 & 0xFF */)) {
          set_has_int64();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
                 input, &int64_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 cached_size = 22;
      case 22: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(176u /* 176 & 0xFF */)) {
          set_has_cached_size();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &cached_size_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 extensions = 23;
      case 23: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(184u /* 184 & 0xFF */)) {
          set_has_extensions();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &extensions_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 bit = 24;
      case 24: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(192u /* 192 & 0xFF */)) {
          set_has_bit();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &bit_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 bits = 25;
      case 25: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(200u /* 200 & 0xFF */)) {
          set_has_bits();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &bits_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 offsets = 26;
      case 26: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(208u /* 208 & 0xFF */)) {
          set_has_offsets();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &offsets_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 reflection = 27;
      case 27: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(216u /* 216 & 0xFF */)) {
          set_has_reflection();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &reflection_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional string some_cord = 28 [ctype = CORD];
      case 28: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(226u /* 226 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_some_cord()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->some_cord().data(), static_cast<int>(this->some_cord().length()),
            ::google::protobuf::internal::WireFormat::PARSE,
            "protobuf_unittest.TestConflictingSymbolNames.some_cord");
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional string some_string_piece = 29 [ctype = STRING_PIECE];
      case 29: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(234u /* 234 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_some_string_piece()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->some_string_piece().data(), static_cast<int>(this->some_string_piece().length()),
            ::google::protobuf::internal::WireFormat::PARSE,
            "protobuf_unittest.TestConflictingSymbolNames.some_string_piece");
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 int = 30;
      case 30: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(240u /* 240 & 0xFF */)) {
          set_has_int_();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &int__)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 friend = 31;
      case 31: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(248u /* 248 & 0xFF */)) {
          set_has_friend_();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &friend__)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .protobuf_unittest.TestConflictingSymbolNames.DO do = 32;
      case 32: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(2u /* 258 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_do_()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 field_type = 33;
      case 33: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u /* 264 & 0xFF */)) {
          set_has_field_type();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &field_type_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional bool is_packed = 34;
      case 34: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u /* 272 & 0xFF */)) {
          set_has_is_packed();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &is_packed_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional string release_length = 35;
      case 35: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(26u /* 282 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_release_length()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->release_length().data(), static_cast<int>(this->release_length().length()),
            ::google::protobuf::internal::WireFormat::PARSE,
            "protobuf_unittest.TestConflictingSymbolNames.release_length");
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .protobuf_unittest.TestConflictingSymbolNames.DO release_do = 36;
      case 36: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(34u /* 290 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(
               input, mutable_release_do()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 class = 37;
      case 37: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(40u /* 296 & 0xFF */)) {
          set_has_class_();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &class__)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional string target = 38;
      case 38: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(50u /* 306 & 0xFF */)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_target()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->target().data(), static_cast<int>(this->target().length()),
            ::google::protobuf::internal::WireFormat::PARSE,
            "protobuf_unittest.TestConflictingSymbolNames.target");
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 typedecl = 39;
      case 39: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(56u /* 312 & 0xFF */)) {
          set_has_typedecl();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &typedecl_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional uint32 auto = 40;
      case 40: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(64u /* 320 & 0xFF */)) {
          set_has_auto_();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &auto__)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        if ((8000u <= tag)) {
          DO_(_extensions_.ParseField(tag, input,
              internal_default_instance(),
              _internal_metadata_.mutable_unknown_fields()));
          continue;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:protobuf_unittest.TestConflictingSymbolNames)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:protobuf_unittest.TestConflictingSymbolNames)
  return false;
#undef DO_
}

void TestConflictingSymbolNames::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:protobuf_unittest.TestConflictingSymbolNames)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional int32 input = 1;
  if (cached_has_bits & 0x00000100u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->input(), output);
  }

  // optional int32 output = 2;
  if (cached_has_bits & 0x00000200u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->output(), output);
  }

  // optional string length = 3;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->length().data(), static_cast<int>(this->length().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "protobuf_unittest.TestConflictingSymbolNames.length");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      3, this->length(), output);
  }

  // repeated int32 i = 4;
  for (int i = 0, n = this->i_size(); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(
      4, this->i(i), output);
  }

  // repeated string new_element = 5 [ctype = STRING_PIECE];
  for (int i = 0, n = this->new_element_size(); i < n; i++) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->new_element(i).data(), static_cast<int>(this->new_element(i).length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "protobuf_unittest.TestConflictingSymbolNames.new_element");
    ::google::protobuf::internal::WireFormatLite::WriteString(
      5, this->new_element(i), output);
  }

  // optional int32 total_size = 6;
  if (cached_has_bits & 0x00000400u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(6, this->total_size(), output);
  }

  // optional int32 tag = 7;
  if (cached_has_bits & 0x00000800u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(7, this->tag(), output);
  }

  // optional int32 source = 8;
  if (cached_has_bits & 0x00001000u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(8, this->source(), output);
  }

  // optional int32 value = 9;
  if (cached_has_bits & 0x00002000u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(9, this->value(), output);
  }

  // optional int32 file = 10;
  if (cached_has_bits & 0x00004000u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(10, this->file(), output);
  }

  // optional int32 from = 11;
  if (cached_has_bits & 0x00008000u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(11, this->from(), output);
  }

  // optional int32 handle_uninterpreted = 12;
  if (cached_has_bits & 0x00010000u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(12, this->handle_uninterpreted(), output);
  }

  // repeated int32 index = 13;
  for (int i = 0, n = this->index_size(); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(
      13, this->index(i), output);
  }

  // optional int32 controller = 14;
  if (cached_has_bits & 0x00020000u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(14, this->controller(), output);
  }

  // optional int32 already_here = 15;
  if (cached_has_bits & 0x00040000u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(15, this->already_here(), output);
  }

  // optional uint32 uint32 = 16;
  if (cached_has_bits & 0x00080000u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(16, this->uint32(), output);
  }

  // optional uint64 uint64 = 17;
  if (cached_has_bits & 0x00100000u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt64(17, this->uint64(), output);
  }

  // optional string string = 18;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->string().data(), static_cast<int>(this->string().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "protobuf_unittest.TestConflictingSymbolNames.string");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      18, this->string(), output);
  }

  // optional int32 memset = 19;
  if (cached_has_bits & 0x00200000u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(19, this->memset(), output);
  }

  // optional int32 int32 = 20;
  if (cached_has_bits & 0x00400000u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(20, this->int32(), output);
  }

  // optional int64 int64 = 21;
  if (cached_has_bits & 0x00800000u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt64(21, this->int64(), output);
  }

  // optional uint32 cached_size = 22;
  if (cached_has_bits & 0x01000000u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(22, this->cached_size(), output);
  }

  // optional uint32 extensions = 23;
  if (cached_has_bits & 0x02000000u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(23, this->extensions(), output);
  }

  // optional uint32 bit = 24;
  if (cached_has_bits & 0x04000000u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(24, this->bit(), output);
  }

  // optional uint32 bits = 25;
  if (cached_has_bits & 0x08000000u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(25, this->bits(), output);
  }

  // optional uint32 offsets = 26;
  if (cached_has_bits & 0x10000000u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(26, this->offsets(), output);
  }

  // optional uint32 reflection = 27;
  if (cached_has_bits & 0x20000000u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(27, this->reflection(), output);
  }

  // optional string some_cord = 28 [ctype = CORD];
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->some_cord().data(), static_cast<int>(this->some_cord().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "protobuf_unittest.TestConflictingSymbolNames.some_cord");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      28, this->some_cord(), output);
  }

  // optional string some_string_piece = 29 [ctype = STRING_PIECE];
  if (cached_has_bits & 0x00000008u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->some_string_piece().data(), static_cast<int>(this->some_string_piece().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "protobuf_unittest.TestConflictingSymbolNames.some_string_piece");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      29, this->some_string_piece(), output);
  }

  // optional uint32 int = 30;
  if (cached_has_bits & 0x40000000u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(30, this->int_(), output);
  }

  // optional uint32 friend = 31;
  if (cached_has_bits & 0x80000000u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(31, this->friend_(), output);
  }

  // optional .protobuf_unittest.TestConflictingSymbolNames.DO do = 32;
  if (cached_has_bits & 0x00000040u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      32, this->_internal_do_(), output);
  }

  cached_has_bits = _has_bits_[1];
  // optional int32 field_type = 33;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(33, this->field_type(), output);
  }

  // optional bool is_packed = 34;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(34, this->is_packed(), output);
  }

  cached_has_bits = _has_bits_[0];
  // optional string release_length = 35;
  if (cached_has_bits & 0x00000010u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->release_length().data(), static_cast<int>(this->release_length().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "protobuf_unittest.TestConflictingSymbolNames.release_length");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      35, this->release_length(), output);
  }

  // optional .protobuf_unittest.TestConflictingSymbolNames.DO release_do = 36;
  if (cached_has_bits & 0x00000080u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      36, this->_internal_release_do(), output);
  }

  cached_has_bits = _has_bits_[1];
  // optional uint32 class = 37;
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(37, this->class_(), output);
  }

  cached_has_bits = _has_bits_[0];
  // optional string target = 38;
  if (cached_has_bits & 0x00000020u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->target().data(), static_cast<int>(this->target().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "protobuf_unittest.TestConflictingSymbolNames.target");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      38, this->target(), output);
  }

  cached_has_bits = _has_bits_[1];
  // optional uint32 typedecl = 39;
  if (cached_has_bits & 0x00000008u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(39, this->typedecl(), output);
  }

  // optional uint32 auto = 40;
  if (cached_has_bits & 0x00000010u) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(40, this->auto_(), output);
  }

  // Extension range [1000, 536870912)
  _extensions_.SerializeWithCachedSizes(
      1000, 536870912, output);

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:protobuf_unittest.TestConflictingSymbolNames)
}

::google::protobuf::uint8* TestConflictingSymbolNames::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:protobuf_unittest.TestConflictingSymbolNames)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional int32 input = 1;
  if (cached_has_bits & 0x00000100u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->input(), target);
  }

  // optional int32 output = 2;
  if (cached_has_bits & 0x00000200u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->output(), target);
  }

  // optional string length = 3;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->length().data(), static_cast<int>(this->length().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "protobuf_unittest.TestConflictingSymbolNames.length");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        3, this->length(), target);
  }

  // repeated int32 i = 4;
  target = ::google::protobuf::internal::WireFormatLite::
    WriteInt32ToArray(4, this->i_, target);

  // repeated string new_element = 5 [ctype = STRING_PIECE];
  for (int i = 0, n = this->new_element_size(); i < n; i++) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->new_element(i).data(), static_cast<int>(this->new_element(i).length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "protobuf_unittest.TestConflictingSymbolNames.new_element");
    target = ::google::protobuf::internal::WireFormatLite::
      WriteStringToArray(5, this->new_element(i), target);
  }

  // optional int32 total_size = 6;
  if (cached_has_bits & 0x00000400u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(6, this->total_size(), target);
  }

  // optional int32 tag = 7;
  if (cached_has_bits & 0x00000800u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(7, this->tag(), target);
  }

  // optional int32 source = 8;
  if (cached_has_bits & 0x00001000u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(8, this->source(), target);
  }

  // optional int32 value = 9;
  if (cached_has_bits & 0x00002000u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(9, this->value(), target);
  }

  // optional int32 file = 10;
  if (cached_has_bits & 0x00004000u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(10, this->file(), target);
  }

  // optional int32 from = 11;
  if (cached_has_bits & 0x00008000u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(11, this->from(), target);
  }

  // optional int32 handle_uninterpreted = 12;
  if (cached_has_bits & 0x00010000u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(12, this->handle_uninterpreted(), target);
  }

  // repeated int32 index = 13;
  target = ::google::protobuf::internal::WireFormatLite::
    WriteInt32ToArray(13, this->index_, target);

  // optional int32 controller = 14;
  if (cached_has_bits & 0x00020000u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(14, this->controller(), target);
  }

  // optional int32 already_here = 15;
  if (cached_has_bits & 0x00040000u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(15, this->already_here(), target);
  }

  // optional uint32 uint32 = 16;
  if (cached_has_bits & 0x00080000u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(16, this->uint32(), target);
  }

  // optional uint64 uint64 = 17;
  if (cached_has_bits & 0x00100000u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(17, this->uint64(), target);
  }

  // optional string string = 18;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->string().data(), static_cast<int>(this->string().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "protobuf_unittest.TestConflictingSymbolNames.string");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        18, this->string(), target);
  }

  // optional int32 memset = 19;
  if (cached_has_bits & 0x00200000u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(19, this->memset(), target);
  }

  // optional int32 int32 = 20;
  if (cached_has_bits & 0x00400000u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(20, this->int32(), target);
  }

  // optional int64 int64 = 21;
  if (cached_has_bits & 0x00800000u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(21, this->int64(), target);
  }

  // optional uint32 cached_size = 22;
  if (cached_has_bits & 0x01000000u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(22, this->cached_size(), target);
  }

  // optional uint32 extensions = 23;
  if (cached_has_bits & 0x02000000u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(23, this->extensions(), target);
  }

  // optional uint32 bit = 24;
  if (cached_has_bits & 0x04000000u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(24, this->bit(), target);
  }

  // optional uint32 bits = 25;
  if (cached_has_bits & 0x08000000u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(25, this->bits(), target);
  }

  // optional uint32 offsets = 26;
  if (cached_has_bits & 0x10000000u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(26, this->offsets(), target);
  }

  // optional uint32 reflection = 27;
  if (cached_has_bits & 0x20000000u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(27, this->reflection(), target);
  }

  // optional string some_cord = 28 [ctype = CORD];
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->some_cord().data(), static_cast<int>(this->some_cord().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "protobuf_unittest.TestConflictingSymbolNames.some_cord");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        28, this->some_cord(), target);
  }

  // optional string some_string_piece = 29 [ctype = STRING_PIECE];
  if (cached_has_bits & 0x00000008u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->some_string_piece().data(), static_cast<int>(this->some_string_piece().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "protobuf_unittest.TestConflictingSymbolNames.some_string_piece");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        29, this->some_string_piece(), target);
  }

  // optional uint32 int = 30;
  if (cached_has_bits & 0x40000000u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(30, this->int_(), target);
  }

  // optional uint32 friend = 31;
  if (cached_has_bits & 0x80000000u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(31, this->friend_(), target);
  }

  // optional .protobuf_unittest.TestConflictingSymbolNames.DO do = 32;
  if (cached_has_bits & 0x00000040u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        32, this->_internal_do_(), deterministic, target);
  }

  cached_has_bits = _has_bits_[1];
  // optional int32 field_type = 33;
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(33, this->field_type(), target);
  }

  // optional bool is_packed = 34;
  if (cached_has_bits & 0x00000002u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(34, this->is_packed(), target);
  }

  cached_has_bits = _has_bits_[0];
  // optional string release_length = 35;
  if (cached_has_bits & 0x00000010u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->release_length().data(), static_cast<int>(this->release_length().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "protobuf_unittest.TestConflictingSymbolNames.release_length");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        35, this->release_length(), target);
  }

  // optional .protobuf_unittest.TestConflictingSymbolNames.DO release_do = 36;
  if (cached_has_bits & 0x00000080u) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageToArray(
        36, this->_internal_release_do(), deterministic, target);
  }

  cached_has_bits = _has_bits_[1];
  // optional uint32 class = 37;
  if (cached_has_bits & 0x00000004u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(37, this->class_(), target);
  }

  cached_has_bits = _has_bits_[0];
  // optional string target = 38;
  if (cached_has_bits & 0x00000020u) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->target().data(), static_cast<int>(this->target().length()),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "protobuf_unittest.TestConflictingSymbolNames.target");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        38, this->target(), target);
  }

  cached_has_bits = _has_bits_[1];
  // optional uint32 typedecl = 39;
  if (cached_has_bits & 0x00000008u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(39, this->typedecl(), target);
  }

  // optional uint32 auto = 40;
  if (cached_has_bits & 0x00000010u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(40, this->auto_(), target);
  }

  // Extension range [1000, 536870912)
  target = _extensions_.InternalSerializeWithCachedSizesToArray(
      1000, 536870912, deterministic, target);

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:protobuf_unittest.TestConflictingSymbolNames)
  return target;
}

size_t TestConflictingSymbolNames::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:protobuf_unittest.TestConflictingSymbolNames)
  size_t total_size = 0;

  total_size += _extensions_.ByteSize();

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  // repeated int32 i = 4;
  {
    size_t data_size = ::google::protobuf::internal::WireFormatLite::
      Int32Size(this->i_);
    total_size += 1 *
                  ::google::protobuf::internal::FromIntSize(this->i_size());
    total_size += data_size;
  }

  // repeated string new_element = 5 [ctype = STRING_PIECE];
  total_size += 1 *
      ::google::protobuf::internal::FromIntSize(this->new_element_size());
  for (int i = 0, n = this->new_element_size(); i < n; i++) {
    total_size += ::google::protobuf::internal::WireFormatLite::StringSize(
      this->new_element(i));
  }

  // repeated int32 index = 13;
  {
    size_t data_size = ::google::protobuf::internal::WireFormatLite::
      Int32Size(this->index_);
    total_size += 1 *
                  ::google::protobuf::internal::FromIntSize(this->index_size());
    total_size += data_size;
  }

  if (_has_bits_[0 / 32] & 255u) {
    // optional string length = 3;
    if (has_length()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->length());
    }

    // optional string string = 18;
    if (has_string()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->string());
    }

    // optional string some_cord = 28 [ctype = CORD];
    if (has_some_cord()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->some_cord());
    }

    // optional string some_string_piece = 29 [ctype = STRING_PIECE];
    if (has_some_string_piece()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->some_string_piece());
    }

    // optional string release_length = 35;
    if (has_release_length()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->release_length());
    }

    // optional string target = 38;
    if (has_target()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->target());
    }

    // optional .protobuf_unittest.TestConflictingSymbolNames.DO do = 32;
    if (has_do_()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *do__);
    }

    // optional .protobuf_unittest.TestConflictingSymbolNames.DO release_do = 36;
    if (has_release_do()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::MessageSize(
          *release_do_);
    }

  }
  if (_has_bits_[8 / 32] & 65280u) {
    // optional int32 input = 1;
    if (has_input()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->input());
    }

    // optional int32 output = 2;
    if (has_output()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->output());
    }

    // optional int32 total_size = 6;
    if (has_total_size()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->total_size());
    }

    // optional int32 tag = 7;
    if (has_tag()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->tag());
    }

    // optional int32 source = 8;
    if (has_source()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->source());
    }

    // optional int32 value = 9;
    if (has_value()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->value());
    }

    // optional int32 file = 10;
    if (has_file()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->file());
    }

    // optional int32 from = 11;
    if (has_from()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->from());
    }

  }
  if (_has_bits_[16 / 32] & 16711680u) {
    // optional int32 handle_uninterpreted = 12;
    if (has_handle_uninterpreted()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->handle_uninterpreted());
    }

    // optional int32 controller = 14;
    if (has_controller()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->controller());
    }

    // optional int32 already_here = 15;
    if (has_already_here()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->already_here());
    }

    // optional uint32 uint32 = 16;
    if (has_uint32()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->uint32());
    }

    // optional uint64 uint64 = 17;
    if (has_uint64()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::UInt64Size(
          this->uint64());
    }

    // optional int32 memset = 19;
    if (has_memset()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->memset());
    }

    // optional int32 int32 = 20;
    if (has_int32()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->int32());
    }

    // optional int64 int64 = 21;
    if (has_int64()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::Int64Size(
          this->int64());
    }

  }
  if (_has_bits_[24 / 32] & 4278190080u) {
    // optional uint32 cached_size = 22;
    if (has_cached_size()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->cached_size());
    }

    // optional uint32 extensions = 23;
    if (has_extensions()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->extensions());
    }

    // optional uint32 bit = 24;
    if (has_bit()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->bit());
    }

    // optional uint32 bits = 25;
    if (has_bits()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->bits());
    }

    // optional uint32 offsets = 26;
    if (has_offsets()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->offsets());
    }

    // optional uint32 reflection = 27;
    if (has_reflection()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->reflection());
    }

    // optional uint32 int = 30;
    if (has_int_()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->int_());
    }

    // optional uint32 friend = 31;
    if (has_friend_()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->friend_());
    }

  }
  if (_has_bits_[32 / 32] & 31u) {
    // optional int32 field_type = 33;
    if (has_field_type()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->field_type());
    }

    // optional bool is_packed = 34;
    if (has_is_packed()) {
      total_size += 2 + 1;
    }

    // optional uint32 class = 37;
    if (has_class_()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->class_());
    }

    // optional uint32 typedecl = 39;
    if (has_typedecl()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->typedecl());
    }

    // optional uint32 auto = 40;
    if (has_auto_()) {
      total_size += 2 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->auto_());
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void TestConflictingSymbolNames::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:protobuf_unittest.TestConflictingSymbolNames)
  GOOGLE_DCHECK_NE(&from, this);
  const TestConflictingSymbolNames* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const TestConflictingSymbolNames>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:protobuf_unittest.TestConflictingSymbolNames)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:protobuf_unittest.TestConflictingSymbolNames)
    MergeFrom(*source);
  }
}

void TestConflictingSymbolNames::MergeFrom(const TestConflictingSymbolNames& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:protobuf_unittest.TestConflictingSymbolNames)
  GOOGLE_DCHECK_NE(&from, this);
  _extensions_.MergeFrom(from._extensions_);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  i_.MergeFrom(from.i_);
  new_element_.MergeFrom(from.new_element_);
  index_.MergeFrom(from.index_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 255u) {
    if (cached_has_bits & 0x00000001u) {
      set_has_length();
      length_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.length_);
    }
    if (cached_has_bits & 0x00000002u) {
      set_has_string();
      string_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.string_);
    }
    if (cached_has_bits & 0x00000004u) {
      set_has_some_cord();
      some_cord_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.some_cord_);
    }
    if (cached_has_bits & 0x00000008u) {
      set_has_some_string_piece();
      some_string_piece_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.some_string_piece_);
    }
    if (cached_has_bits & 0x00000010u) {
      set_has_release_length();
      release_length_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.release_length_);
    }
    if (cached_has_bits & 0x00000020u) {
      set_has_target();
      target_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.target_);
    }
    if (cached_has_bits & 0x00000040u) {
      mutable_do_()->::protobuf_unittest::TestConflictingSymbolNames_DO::MergeFrom(from.do_());
    }
    if (cached_has_bits & 0x00000080u) {
      mutable_release_do()->::protobuf_unittest::TestConflictingSymbolNames_DO::MergeFrom(from.release_do());
    }
  }
  if (cached_has_bits & 65280u) {
    if (cached_has_bits & 0x00000100u) {
      input_ = from.input_;
    }
    if (cached_has_bits & 0x00000200u) {
      output_ = from.output_;
    }
    if (cached_has_bits & 0x00000400u) {
      total_size_ = from.total_size_;
    }
    if (cached_has_bits & 0x00000800u) {
      tag_ = from.tag_;
    }
    if (cached_has_bits & 0x00001000u) {
      source_ = from.source_;
    }
    if (cached_has_bits & 0x00002000u) {
      value_ = from.value_;
    }
    if (cached_has_bits & 0x00004000u) {
      file_ = from.file_;
    }
    if (cached_has_bits & 0x00008000u) {
      from_ = from.from_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  if (cached_has_bits & 16711680u) {
    if (cached_has_bits & 0x00010000u) {
      handle_uninterpreted_ = from.handle_uninterpreted_;
    }
    if (cached_has_bits & 0x00020000u) {
      controller_ = from.controller_;
    }
    if (cached_has_bits & 0x00040000u) {
      already_here_ = from.already_here_;
    }
    if (cached_has_bits & 0x00080000u) {
      uint32_ = from.uint32_;
    }
    if (cached_has_bits & 0x00100000u) {
      uint64_ = from.uint64_;
    }
    if (cached_has_bits & 0x00200000u) {
      memset_ = from.memset_;
    }
    if (cached_has_bits & 0x00400000u) {
      int32_ = from.int32_;
    }
    if (cached_has_bits & 0x00800000u) {
      int64_ = from.int64_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  if (cached_has_bits & 4278190080u) {
    if (cached_has_bits & 0x01000000u) {
      cached_size_ = from.cached_size_;
    }
    if (cached_has_bits & 0x02000000u) {
      extensions_ = from.extensions_;
    }
    if (cached_has_bits & 0x04000000u) {
      bit_ = from.bit_;
    }
    if (cached_has_bits & 0x08000000u) {
      bits_ = from.bits_;
    }
    if (cached_has_bits & 0x10000000u) {
      offsets_ = from.offsets_;
    }
    if (cached_has_bits & 0x20000000u) {
      reflection_ = from.reflection_;
    }
    if (cached_has_bits & 0x40000000u) {
      int__ = from.int__;
    }
    if (cached_has_bits & 0x80000000u) {
      friend__ = from.friend__;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  cached_has_bits = from._has_bits_[1];
  if (cached_has_bits & 31u) {
    if (cached_has_bits & 0x00000001u) {
      field_type_ = from.field_type_;
    }
    if (cached_has_bits & 0x00000002u) {
      is_packed_ = from.is_packed_;
    }
    if (cached_has_bits & 0x00000004u) {
      class__ = from.class__;
    }
    if (cached_has_bits & 0x00000008u) {
      typedecl_ = from.typedecl_;
    }
    if (cached_has_bits & 0x00000010u) {
      auto__ = from.auto__;
    }
    _has_bits_[1] |= cached_has_bits;
  }
}

void TestConflictingSymbolNames::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:protobuf_unittest.TestConflictingSymbolNames)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void TestConflictingSymbolNames::CopyFrom(const TestConflictingSymbolNames& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:protobuf_unittest.TestConflictingSymbolNames)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool TestConflictingSymbolNames::IsInitialized() const {
  if (!_extensions_.IsInitialized()) {
    return false;
  }

  return true;
}

void TestConflictingSymbolNames::Swap(TestConflictingSymbolNames* other) {
  if (other == this) return;
  InternalSwap(other);
}
void TestConflictingSymbolNames::InternalSwap(TestConflictingSymbolNames* other) {
  using std::swap;
  i_.InternalSwap(&other->i_);
  new_element_.InternalSwap(CastToBase(&other->new_element_));
  index_.InternalSwap(&other->index_);
  length_.Swap(&other->length_, &::google::protobuf::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  string_.Swap(&other->string_, &::google::protobuf::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  some_cord_.Swap(&other->some_cord_, &::google::protobuf::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  some_string_piece_.Swap(&other->some_string_piece_, &::google::protobuf::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  release_length_.Swap(&other->release_length_, &::google::protobuf::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  target_.Swap(&other->target_, &::google::protobuf::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  swap(do__, other->do__);
  swap(release_do_, other->release_do_);
  swap(input_, other->input_);
  swap(output_, other->output_);
  swap(total_size_, other->total_size_);
  swap(tag_, other->tag_);
  swap(source_, other->source_);
  swap(value_, other->value_);
  swap(file_, other->file_);
  swap(from_, other->from_);
  swap(handle_uninterpreted_, other->handle_uninterpreted_);
  swap(controller_, other->controller_);
  swap(already_here_, other->already_here_);
  swap(uint32_, other->uint32_);
  swap(uint64_, other->uint64_);
  swap(memset_, other->memset_);
  swap(int32_, other->int32_);
  swap(int64_, other->int64_);
  swap(cached_size_, other->cached_size_);
  swap(extensions_, other->extensions_);
  swap(bit_, other->bit_);
  swap(bits_, other->bits_);
  swap(offsets_, other->offsets_);
  swap(reflection_, other->reflection_);
  swap(int__, other->int__);
  swap(friend__, other->friend__);
  swap(field_type_, other->field_type_);
  swap(is_packed_, other->is_packed_);
  swap(class__, other->class__);
  swap(typedecl_, other->typedecl_);
  swap(auto__, other->auto__);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(_has_bits_[1], other->_has_bits_[1]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  _extensions_.Swap(&other->_extensions_);
}

::google::protobuf::Metadata TestConflictingSymbolNames::GetMetadata() const {
  protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void TestConflictingSymbolNamesExtension::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

TestConflictingSymbolNamesExtension::TestConflictingSymbolNamesExtension()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  ::google::protobuf::internal::InitSCC(
      &protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::scc_info_TestConflictingSymbolNamesExtension.base);
  SharedCtor();
  // @@protoc_insertion_point(constructor:protobuf_unittest.TestConflictingSymbolNamesExtension)
}
TestConflictingSymbolNamesExtension::TestConflictingSymbolNamesExtension(const TestConflictingSymbolNamesExtension& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:protobuf_unittest.TestConflictingSymbolNamesExtension)
}

void TestConflictingSymbolNamesExtension::SharedCtor() {
}

TestConflictingSymbolNamesExtension::~TestConflictingSymbolNamesExtension() {
  // @@protoc_insertion_point(destructor:protobuf_unittest.TestConflictingSymbolNamesExtension)
  SharedDtor();
}

void TestConflictingSymbolNamesExtension::SharedDtor() {
}

void TestConflictingSymbolNamesExtension::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const ::google::protobuf::Descriptor* TestConflictingSymbolNamesExtension::descriptor() {
  ::protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const TestConflictingSymbolNamesExtension& TestConflictingSymbolNamesExtension::default_instance() {
  ::google::protobuf::internal::InitSCC(&protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::scc_info_TestConflictingSymbolNamesExtension.base);
  return *internal_default_instance();
}


void TestConflictingSymbolNamesExtension::Clear() {
// @@protoc_insertion_point(message_clear_start:protobuf_unittest.TestConflictingSymbolNamesExtension)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool TestConflictingSymbolNamesExtension::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:protobuf_unittest.TestConflictingSymbolNamesExtension)
  for (;;) {
    ::std::pair<::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
  handle_unusual:
    if (tag == 0) {
      goto success;
    }
    DO_(::google::protobuf::internal::WireFormat::SkipField(
          input, tag, _internal_metadata_.mutable_unknown_fields()));
  }
success:
  // @@protoc_insertion_point(parse_success:protobuf_unittest.TestConflictingSymbolNamesExtension)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:protobuf_unittest.TestConflictingSymbolNamesExtension)
  return false;
#undef DO_
}

void TestConflictingSymbolNamesExtension::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:protobuf_unittest.TestConflictingSymbolNamesExtension)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:protobuf_unittest.TestConflictingSymbolNamesExtension)
}

::google::protobuf::uint8* TestConflictingSymbolNamesExtension::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:protobuf_unittest.TestConflictingSymbolNamesExtension)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:protobuf_unittest.TestConflictingSymbolNamesExtension)
  return target;
}

size_t TestConflictingSymbolNamesExtension::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:protobuf_unittest.TestConflictingSymbolNamesExtension)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void TestConflictingSymbolNamesExtension::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:protobuf_unittest.TestConflictingSymbolNamesExtension)
  GOOGLE_DCHECK_NE(&from, this);
  const TestConflictingSymbolNamesExtension* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const TestConflictingSymbolNamesExtension>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:protobuf_unittest.TestConflictingSymbolNamesExtension)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:protobuf_unittest.TestConflictingSymbolNamesExtension)
    MergeFrom(*source);
  }
}

void TestConflictingSymbolNamesExtension::MergeFrom(const TestConflictingSymbolNamesExtension& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:protobuf_unittest.TestConflictingSymbolNamesExtension)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

}

void TestConflictingSymbolNamesExtension::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:protobuf_unittest.TestConflictingSymbolNamesExtension)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void TestConflictingSymbolNamesExtension::CopyFrom(const TestConflictingSymbolNamesExtension& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:protobuf_unittest.TestConflictingSymbolNamesExtension)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool TestConflictingSymbolNamesExtension::IsInitialized() const {
  return true;
}

void TestConflictingSymbolNamesExtension::Swap(TestConflictingSymbolNamesExtension* other) {
  if (other == this) return;
  InternalSwap(other);
}
void TestConflictingSymbolNamesExtension::InternalSwap(TestConflictingSymbolNamesExtension* other) {
  using std::swap;
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
}

::google::protobuf::Metadata TestConflictingSymbolNamesExtension::GetMetadata() const {
  protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void TestConflictingEnumNames::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int TestConflictingEnumNames::kConflictingEnumFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

TestConflictingEnumNames::TestConflictingEnumNames()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  ::google::protobuf::internal::InitSCC(
      &protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::scc_info_TestConflictingEnumNames.base);
  SharedCtor();
  // @@protoc_insertion_point(constructor:protobuf_unittest.TestConflictingEnumNames)
}
TestConflictingEnumNames::TestConflictingEnumNames(const TestConflictingEnumNames& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  conflicting_enum_ = from.conflicting_enum_;
  // @@protoc_insertion_point(copy_constructor:protobuf_unittest.TestConflictingEnumNames)
}

void TestConflictingEnumNames::SharedCtor() {
  conflicting_enum_ = 1;
}

TestConflictingEnumNames::~TestConflictingEnumNames() {
  // @@protoc_insertion_point(destructor:protobuf_unittest.TestConflictingEnumNames)
  SharedDtor();
}

void TestConflictingEnumNames::SharedDtor() {
}

void TestConflictingEnumNames::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const ::google::protobuf::Descriptor* TestConflictingEnumNames::descriptor() {
  ::protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const TestConflictingEnumNames& TestConflictingEnumNames::default_instance() {
  ::google::protobuf::internal::InitSCC(&protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::scc_info_TestConflictingEnumNames.base);
  return *internal_default_instance();
}


void TestConflictingEnumNames::Clear() {
// @@protoc_insertion_point(message_clear_start:protobuf_unittest.TestConflictingEnumNames)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  conflicting_enum_ = 1;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool TestConflictingEnumNames::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:protobuf_unittest.TestConflictingEnumNames)
  for (;;) {
    ::std::pair<::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .protobuf_unittest.TestConflictingEnumNames.NestedConflictingEnum conflicting_enum = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::protobuf_unittest::TestConflictingEnumNames_NestedConflictingEnum_IsValid(value)) {
            set_conflicting_enum(static_cast< ::protobuf_unittest::TestConflictingEnumNames_NestedConflictingEnum >(value));
          } else {
            mutable_unknown_fields()->AddVarint(
                1, static_cast< ::google::protobuf::uint64>(value));
          }
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, _internal_metadata_.mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:protobuf_unittest.TestConflictingEnumNames)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:protobuf_unittest.TestConflictingEnumNames)
  return false;
#undef DO_
}

void TestConflictingEnumNames::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:protobuf_unittest.TestConflictingEnumNames)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .protobuf_unittest.TestConflictingEnumNames.NestedConflictingEnum conflicting_enum = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->conflicting_enum(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:protobuf_unittest.TestConflictingEnumNames)
}

::google::protobuf::uint8* TestConflictingEnumNames::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:protobuf_unittest.TestConflictingEnumNames)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .protobuf_unittest.TestConflictingEnumNames.NestedConflictingEnum conflicting_enum = 1;
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      1, this->conflicting_enum(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:protobuf_unittest.TestConflictingEnumNames)
  return target;
}

size_t TestConflictingEnumNames::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:protobuf_unittest.TestConflictingEnumNames)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  // optional .protobuf_unittest.TestConflictingEnumNames.NestedConflictingEnum conflicting_enum = 1;
  if (has_conflicting_enum()) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::EnumSize(this->conflicting_enum());
  }

  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void TestConflictingEnumNames::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:protobuf_unittest.TestConflictingEnumNames)
  GOOGLE_DCHECK_NE(&from, this);
  const TestConflictingEnumNames* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const TestConflictingEnumNames>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:protobuf_unittest.TestConflictingEnumNames)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:protobuf_unittest.TestConflictingEnumNames)
    MergeFrom(*source);
  }
}

void TestConflictingEnumNames::MergeFrom(const TestConflictingEnumNames& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:protobuf_unittest.TestConflictingEnumNames)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.has_conflicting_enum()) {
    set_conflicting_enum(from.conflicting_enum());
  }
}

void TestConflictingEnumNames::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:protobuf_unittest.TestConflictingEnumNames)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void TestConflictingEnumNames::CopyFrom(const TestConflictingEnumNames& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:protobuf_unittest.TestConflictingEnumNames)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool TestConflictingEnumNames::IsInitialized() const {
  return true;
}

void TestConflictingEnumNames::Swap(TestConflictingEnumNames* other) {
  if (other == this) return;
  InternalSwap(other);
}
void TestConflictingEnumNames::InternalSwap(TestConflictingEnumNames* other) {
  using std::swap;
  swap(conflicting_enum_, other->conflicting_enum_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
}

::google::protobuf::Metadata TestConflictingEnumNames::GetMetadata() const {
  protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void DummyMessage::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

DummyMessage::DummyMessage()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  ::google::protobuf::internal::InitSCC(
      &protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::scc_info_DummyMessage.base);
  SharedCtor();
  // @@protoc_insertion_point(constructor:protobuf_unittest.DummyMessage)
}
DummyMessage::DummyMessage(const DummyMessage& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:protobuf_unittest.DummyMessage)
}

void DummyMessage::SharedCtor() {
}

DummyMessage::~DummyMessage() {
  // @@protoc_insertion_point(destructor:protobuf_unittest.DummyMessage)
  SharedDtor();
}

void DummyMessage::SharedDtor() {
}

void DummyMessage::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const ::google::protobuf::Descriptor* DummyMessage::descriptor() {
  ::protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const DummyMessage& DummyMessage::default_instance() {
  ::google::protobuf::internal::InitSCC(&protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::scc_info_DummyMessage.base);
  return *internal_default_instance();
}


void DummyMessage::Clear() {
// @@protoc_insertion_point(message_clear_start:protobuf_unittest.DummyMessage)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool DummyMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:protobuf_unittest.DummyMessage)
  for (;;) {
    ::std::pair<::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
  handle_unusual:
    if (tag == 0) {
      goto success;
    }
    DO_(::google::protobuf::internal::WireFormat::SkipField(
          input, tag, _internal_metadata_.mutable_unknown_fields()));
  }
success:
  // @@protoc_insertion_point(parse_success:protobuf_unittest.DummyMessage)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:protobuf_unittest.DummyMessage)
  return false;
#undef DO_
}

void DummyMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:protobuf_unittest.DummyMessage)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:protobuf_unittest.DummyMessage)
}

::google::protobuf::uint8* DummyMessage::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:protobuf_unittest.DummyMessage)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:protobuf_unittest.DummyMessage)
  return target;
}

size_t DummyMessage::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:protobuf_unittest.DummyMessage)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void DummyMessage::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:protobuf_unittest.DummyMessage)
  GOOGLE_DCHECK_NE(&from, this);
  const DummyMessage* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const DummyMessage>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:protobuf_unittest.DummyMessage)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:protobuf_unittest.DummyMessage)
    MergeFrom(*source);
  }
}

void DummyMessage::MergeFrom(const DummyMessage& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:protobuf_unittest.DummyMessage)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

}

void DummyMessage::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:protobuf_unittest.DummyMessage)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void DummyMessage::CopyFrom(const DummyMessage& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:protobuf_unittest.DummyMessage)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool DummyMessage::IsInitialized() const {
  return true;
}

void DummyMessage::Swap(DummyMessage* other) {
  if (other == this) return;
  InternalSwap(other);
}
void DummyMessage::InternalSwap(DummyMessage* other) {
  using std::swap;
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
}

::google::protobuf::Metadata DummyMessage::GetMetadata() const {
  protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void Shutdown::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

Shutdown::Shutdown()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  ::google::protobuf::internal::InitSCC(
      &protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::scc_info_Shutdown.base);
  SharedCtor();
  // @@protoc_insertion_point(constructor:protobuf_unittest.Shutdown)
}
Shutdown::Shutdown(const Shutdown& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:protobuf_unittest.Shutdown)
}

void Shutdown::SharedCtor() {
}

Shutdown::~Shutdown() {
  // @@protoc_insertion_point(destructor:protobuf_unittest.Shutdown)
  SharedDtor();
}

void Shutdown::SharedDtor() {
}

void Shutdown::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const ::google::protobuf::Descriptor* Shutdown::descriptor() {
  ::protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const Shutdown& Shutdown::default_instance() {
  ::google::protobuf::internal::InitSCC(&protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::scc_info_Shutdown.base);
  return *internal_default_instance();
}


void Shutdown::Clear() {
// @@protoc_insertion_point(message_clear_start:protobuf_unittest.Shutdown)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool Shutdown::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:protobuf_unittest.Shutdown)
  for (;;) {
    ::std::pair<::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
  handle_unusual:
    if (tag == 0) {
      goto success;
    }
    DO_(::google::protobuf::internal::WireFormat::SkipField(
          input, tag, _internal_metadata_.mutable_unknown_fields()));
  }
success:
  // @@protoc_insertion_point(parse_success:protobuf_unittest.Shutdown)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:protobuf_unittest.Shutdown)
  return false;
#undef DO_
}

void Shutdown::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:protobuf_unittest.Shutdown)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:protobuf_unittest.Shutdown)
}

::google::protobuf::uint8* Shutdown::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:protobuf_unittest.Shutdown)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:protobuf_unittest.Shutdown)
  return target;
}

size_t Shutdown::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:protobuf_unittest.Shutdown)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void Shutdown::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:protobuf_unittest.Shutdown)
  GOOGLE_DCHECK_NE(&from, this);
  const Shutdown* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const Shutdown>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:protobuf_unittest.Shutdown)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:protobuf_unittest.Shutdown)
    MergeFrom(*source);
  }
}

void Shutdown::MergeFrom(const Shutdown& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:protobuf_unittest.Shutdown)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

}

void Shutdown::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:protobuf_unittest.Shutdown)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void Shutdown::CopyFrom(const Shutdown& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:protobuf_unittest.Shutdown)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Shutdown::IsInitialized() const {
  return true;
}

void Shutdown::Swap(Shutdown* other) {
  if (other == this) return;
  InternalSwap(other);
}
void Shutdown::InternalSwap(Shutdown* other) {
  using std::swap;
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
}

::google::protobuf::Metadata Shutdown::GetMetadata() const {
  protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

void TableStruct::InitAsDefaultInstance() {
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

TableStruct::TableStruct()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  ::google::protobuf::internal::InitSCC(
      &protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::scc_info_TableStruct.base);
  SharedCtor();
  // @@protoc_insertion_point(constructor:protobuf_unittest.TableStruct)
}
TableStruct::TableStruct(const TableStruct& from)
  : ::google::protobuf::Message(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:protobuf_unittest.TableStruct)
}

void TableStruct::SharedCtor() {
}

TableStruct::~TableStruct() {
  // @@protoc_insertion_point(destructor:protobuf_unittest.TableStruct)
  SharedDtor();
}

void TableStruct::SharedDtor() {
}

void TableStruct::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const ::google::protobuf::Descriptor* TableStruct::descriptor() {
  ::protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;
}

const TableStruct& TableStruct::default_instance() {
  ::google::protobuf::internal::InitSCC(&protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::scc_info_TableStruct.base);
  return *internal_default_instance();
}


void TableStruct::Clear() {
// @@protoc_insertion_point(message_clear_start:protobuf_unittest.TableStruct)
  ::google::protobuf::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool TableStruct::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:protobuf_unittest.TableStruct)
  for (;;) {
    ::std::pair<::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
  handle_unusual:
    if (tag == 0) {
      goto success;
    }
    DO_(::google::protobuf::internal::WireFormat::SkipField(
          input, tag, _internal_metadata_.mutable_unknown_fields()));
  }
success:
  // @@protoc_insertion_point(parse_success:protobuf_unittest.TableStruct)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:protobuf_unittest.TableStruct)
  return false;
#undef DO_
}

void TableStruct::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:protobuf_unittest.TableStruct)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        _internal_metadata_.unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:protobuf_unittest.TableStruct)
}

::google::protobuf::uint8* TableStruct::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:protobuf_unittest.TableStruct)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:protobuf_unittest.TableStruct)
  return target;
}

size_t TableStruct::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:protobuf_unittest.TableStruct)
  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        _internal_metadata_.unknown_fields());
  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void TableStruct::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:protobuf_unittest.TableStruct)
  GOOGLE_DCHECK_NE(&from, this);
  const TableStruct* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const TableStruct>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:protobuf_unittest.TableStruct)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:protobuf_unittest.TableStruct)
    MergeFrom(*source);
  }
}

void TableStruct::MergeFrom(const TableStruct& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:protobuf_unittest.TableStruct)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

}

void TableStruct::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:protobuf_unittest.TableStruct)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void TableStruct::CopyFrom(const TableStruct& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:protobuf_unittest.TableStruct)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool TableStruct::IsInitialized() const {
  return true;
}

void TableStruct::Swap(TableStruct* other) {
  if (other == this) return;
  InternalSwap(other);
}
void TableStruct::InternalSwap(TableStruct* other) {
  using std::swap;
  swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
}

::google::protobuf::Metadata TableStruct::GetMetadata() const {
  protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::protobuf_AssignDescriptorsOnce();
  return ::protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::file_level_metadata[kIndexInFileMessages];
}


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

TestConflictingMethodNames::~TestConflictingMethodNames() {}

const ::google::protobuf::ServiceDescriptor* TestConflictingMethodNames::descriptor() {
  protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::protobuf_AssignDescriptorsOnce();
  return protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::file_level_service_descriptors[0];
}

const ::google::protobuf::ServiceDescriptor* TestConflictingMethodNames::GetDescriptor() {
  return descriptor();
}

void TestConflictingMethodNames::Closure(::google::protobuf::RpcController* controller,
                         const ::protobuf_unittest::DummyMessage*,
                         ::protobuf_unittest::DummyMessage*,
                         ::google::protobuf::Closure* done) {
  controller->SetFailed("Method Closure() not implemented.");
  done->Run();
}

void TestConflictingMethodNames::CallMethod(const ::google::protobuf::MethodDescriptor* method,
                             ::google::protobuf::RpcController* controller,
                             const ::google::protobuf::Message* request,
                             ::google::protobuf::Message* response,
                             ::google::protobuf::Closure* done) {
  GOOGLE_DCHECK_EQ(method->service(), protobuf_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto::file_level_service_descriptors[0]);
  switch(method->index()) {
    case 0:
      Closure(controller,
             ::google::protobuf::down_cast<const ::protobuf_unittest::DummyMessage*>(request),
             ::google::protobuf::down_cast< ::protobuf_unittest::DummyMessage*>(response),
             done);
      break;
    default:
      GOOGLE_LOG(FATAL) << "Bad method index; this should never happen.";
      break;
  }
}

const ::google::protobuf::Message& TestConflictingMethodNames::GetRequestPrototype(
    const ::google::protobuf::MethodDescriptor* method) const {
  GOOGLE_DCHECK_EQ(method->service(), descriptor());
  switch(method->index()) {
    case 0:
      return ::protobuf_unittest::DummyMessage::default_instance();
    default:
      GOOGLE_LOG(FATAL) << "Bad method index; this should never happen.";
      return *::google::protobuf::MessageFactory::generated_factory()
          ->GetPrototype(method->input_type());
  }
}

const ::google::protobuf::Message& TestConflictingMethodNames::GetResponsePrototype(
    const ::google::protobuf::MethodDescriptor* method) const {
  GOOGLE_DCHECK_EQ(method->service(), descriptor());
  switch(method->index()) {
    case 0:
      return ::protobuf_unittest::DummyMessage::default_instance();
    default:
      GOOGLE_LOG(FATAL) << "Bad method index; this should never happen.";
      return *::google::protobuf::MessageFactory::generated_factory()
          ->GetPrototype(method->output_type());
  }
}

TestConflictingMethodNames_Stub::TestConflictingMethodNames_Stub(::google::protobuf::RpcChannel* channel)
  : channel_(channel), owns_channel_(false) {}
TestConflictingMethodNames_Stub::TestConflictingMethodNames_Stub(
    ::google::protobuf::RpcChannel* channel,
    ::google::protobuf::Service::ChannelOwnership ownership)
  : channel_(channel),
    owns_channel_(ownership == ::google::protobuf::Service::STUB_OWNS_CHANNEL) {}
TestConflictingMethodNames_Stub::~TestConflictingMethodNames_Stub() {
  if (owns_channel_) delete channel_;
}

void TestConflictingMethodNames_Stub::Closure(::google::protobuf::RpcController* controller,
                              const ::protobuf_unittest::DummyMessage* request,
                              ::protobuf_unittest::DummyMessage* response,
                              ::google::protobuf::Closure* done) {
  channel_->CallMethod(descriptor()->method(0),
                       controller, request, response, done);
}
#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int TestConflictingSymbolNamesExtension::kRepeatedInt32ExtFieldNumber;
#endif
::google::protobuf::internal::ExtensionIdentifier< ::protobuf_unittest::TestConflictingSymbolNames,
    ::google::protobuf::internal::RepeatedPrimitiveTypeTraits< ::google::protobuf::int32 >, 5, true >
  TestConflictingSymbolNamesExtension::repeated_int32_ext(kRepeatedInt32ExtFieldNumber, 0);

// @@protoc_insertion_point(namespace_scope)
}  // namespace protobuf_unittest
namespace google {
namespace protobuf {
template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::protobuf_unittest::TestConflictingSymbolNames_BuildDescriptors* Arena::CreateMaybeMessage< ::protobuf_unittest::TestConflictingSymbolNames_BuildDescriptors >(Arena* arena) {
  return Arena::CreateInternal< ::protobuf_unittest::TestConflictingSymbolNames_BuildDescriptors >(arena);
}
template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::protobuf_unittest::TestConflictingSymbolNames_TypeTraits* Arena::CreateMaybeMessage< ::protobuf_unittest::TestConflictingSymbolNames_TypeTraits >(Arena* arena) {
  return Arena::CreateInternal< ::protobuf_unittest::TestConflictingSymbolNames_TypeTraits >(arena);
}
template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::protobuf_unittest::TestConflictingSymbolNames_Data1* Arena::CreateMaybeMessage< ::protobuf_unittest::TestConflictingSymbolNames_Data1 >(Arena* arena) {
  return Arena::CreateInternal< ::protobuf_unittest::TestConflictingSymbolNames_Data1 >(arena);
}
template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::protobuf_unittest::TestConflictingSymbolNames_Data2* Arena::CreateMaybeMessage< ::protobuf_unittest::TestConflictingSymbolNames_Data2 >(Arena* arena) {
  return Arena::CreateInternal< ::protobuf_unittest::TestConflictingSymbolNames_Data2 >(arena);
}
template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::protobuf_unittest::TestConflictingSymbolNames_Data3* Arena::CreateMaybeMessage< ::protobuf_unittest::TestConflictingSymbolNames_Data3 >(Arena* arena) {
  return Arena::CreateInternal< ::protobuf_unittest::TestConflictingSymbolNames_Data3 >(arena);
}
template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::protobuf_unittest::TestConflictingSymbolNames_Data4* Arena::CreateMaybeMessage< ::protobuf_unittest::TestConflictingSymbolNames_Data4 >(Arena* arena) {
  return Arena::CreateInternal< ::protobuf_unittest::TestConflictingSymbolNames_Data4 >(arena);
}
template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::protobuf_unittest::TestConflictingSymbolNames_Data5* Arena::CreateMaybeMessage< ::protobuf_unittest::TestConflictingSymbolNames_Data5 >(Arena* arena) {
  return Arena::CreateInternal< ::protobuf_unittest::TestConflictingSymbolNames_Data5 >(arena);
}
template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::protobuf_unittest::TestConflictingSymbolNames_Data6* Arena::CreateMaybeMessage< ::protobuf_unittest::TestConflictingSymbolNames_Data6 >(Arena* arena) {
  return Arena::CreateInternal< ::protobuf_unittest::TestConflictingSymbolNames_Data6 >(arena);
}
template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::protobuf_unittest::TestConflictingSymbolNames_Cord* Arena::CreateMaybeMessage< ::protobuf_unittest::TestConflictingSymbolNames_Cord >(Arena* arena) {
  return Arena::CreateInternal< ::protobuf_unittest::TestConflictingSymbolNames_Cord >(arena);
}
template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::protobuf_unittest::TestConflictingSymbolNames_StringPiece* Arena::CreateMaybeMessage< ::protobuf_unittest::TestConflictingSymbolNames_StringPiece >(Arena* arena) {
  return Arena::CreateInternal< ::protobuf_unittest::TestConflictingSymbolNames_StringPiece >(arena);
}
template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::protobuf_unittest::TestConflictingSymbolNames_DO* Arena::CreateMaybeMessage< ::protobuf_unittest::TestConflictingSymbolNames_DO >(Arena* arena) {
  return Arena::CreateInternal< ::protobuf_unittest::TestConflictingSymbolNames_DO >(arena);
}
template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::protobuf_unittest::TestConflictingSymbolNames* Arena::CreateMaybeMessage< ::protobuf_unittest::TestConflictingSymbolNames >(Arena* arena) {
  return Arena::CreateInternal< ::protobuf_unittest::TestConflictingSymbolNames >(arena);
}
template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::protobuf_unittest::TestConflictingSymbolNamesExtension* Arena::CreateMaybeMessage< ::protobuf_unittest::TestConflictingSymbolNamesExtension >(Arena* arena) {
  return Arena::CreateInternal< ::protobuf_unittest::TestConflictingSymbolNamesExtension >(arena);
}
template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::protobuf_unittest::TestConflictingEnumNames* Arena::CreateMaybeMessage< ::protobuf_unittest::TestConflictingEnumNames >(Arena* arena) {
  return Arena::CreateInternal< ::protobuf_unittest::TestConflictingEnumNames >(arena);
}
template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::protobuf_unittest::DummyMessage* Arena::CreateMaybeMessage< ::protobuf_unittest::DummyMessage >(Arena* arena) {
  return Arena::CreateInternal< ::protobuf_unittest::DummyMessage >(arena);
}
template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::protobuf_unittest::Shutdown* Arena::CreateMaybeMessage< ::protobuf_unittest::Shutdown >(Arena* arena) {
  return Arena::CreateInternal< ::protobuf_unittest::Shutdown >(arena);
}
template<> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE ::protobuf_unittest::TableStruct* Arena::CreateMaybeMessage< ::protobuf_unittest::TableStruct >(Arena* arena) {
  return Arena::CreateInternal< ::protobuf_unittest::TableStruct >(arena);
}
}  // namespace protobuf
}  // namespace google

// @@protoc_insertion_point(global_scope)
