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

#ifndef PROTOBUF_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto__INCLUDED
#define PROTOBUF_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto__INCLUDED

#include <string>

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

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

#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/repeated_field.h>
#include <google/protobuf/extension_set.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/service.h>
// @@protoc_insertion_point(includes)

namespace protobuf_unittest {

// Internal implementation detail -- do not call these.
void  protobuf_AddDesc_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto();
void protobuf_AssignDesc_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto();
void protobuf_ShutdownFile_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto();

class TestConflictingSymbolNames;
class TestConflictingSymbolNames_BuildDescriptors;
class TestConflictingSymbolNames_TypeTraits;
class TestConflictingSymbolNames_Data1;
class TestConflictingSymbolNames_Data2;
class TestConflictingSymbolNames_Data3;
class TestConflictingSymbolNames_Data4;
class TestConflictingSymbolNames_Data5;
class TestConflictingSymbolNames_Data6;
class TestConflictingSymbolNames_Cord;
class TestConflictingSymbolNames_StringPiece;
class TestConflictingSymbolNames_DO;
class DummyMessage;

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

const ::google::protobuf::EnumDescriptor* TestConflictingSymbolNames_TestEnum_descriptor();
inline const ::std::string& TestConflictingSymbolNames_TestEnum_Name(TestConflictingSymbolNames_TestEnum value) {
  return ::google::protobuf::internal::NameOfEnum(
    TestConflictingSymbolNames_TestEnum_descriptor(), value);
}
inline bool TestConflictingSymbolNames_TestEnum_Parse(
    const ::std::string& name, TestConflictingSymbolNames_TestEnum* value) {
  return ::google::protobuf::internal::ParseNamedEnum<TestConflictingSymbolNames_TestEnum>(
    TestConflictingSymbolNames_TestEnum_descriptor(), name, value);
}
// ===================================================================

class TestConflictingSymbolNames_BuildDescriptors : public ::google::protobuf::Message {
 public:
  TestConflictingSymbolNames_BuildDescriptors();
  virtual ~TestConflictingSymbolNames_BuildDescriptors();
  
  TestConflictingSymbolNames_BuildDescriptors(const TestConflictingSymbolNames_BuildDescriptors& from);
  
  inline TestConflictingSymbolNames_BuildDescriptors& operator=(const TestConflictingSymbolNames_BuildDescriptors& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const TestConflictingSymbolNames_BuildDescriptors& default_instance();
  
  void Swap(TestConflictingSymbolNames_BuildDescriptors* other);
  
  // implements Message ----------------------------------------------
  
  TestConflictingSymbolNames_BuildDescriptors* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const TestConflictingSymbolNames_BuildDescriptors& from);
  void MergeFrom(const TestConflictingSymbolNames_BuildDescriptors& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestConflictingSymbolNames.BuildDescriptors)
 private:
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[1];
  
  friend void  protobuf_AddDesc_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto();
  friend void protobuf_AssignDesc_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto();
  friend void protobuf_ShutdownFile_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto();
  
  void InitAsDefaultInstance();
  static TestConflictingSymbolNames_BuildDescriptors* default_instance_;
};
// -------------------------------------------------------------------

class TestConflictingSymbolNames_TypeTraits : public ::google::protobuf::Message {
 public:
  TestConflictingSymbolNames_TypeTraits();
  virtual ~TestConflictingSymbolNames_TypeTraits();
  
  TestConflictingSymbolNames_TypeTraits(const TestConflictingSymbolNames_TypeTraits& from);
  
  inline TestConflictingSymbolNames_TypeTraits& operator=(const TestConflictingSymbolNames_TypeTraits& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const TestConflictingSymbolNames_TypeTraits& default_instance();
  
  void Swap(TestConflictingSymbolNames_TypeTraits* other);
  
  // implements Message ----------------------------------------------
  
  TestConflictingSymbolNames_TypeTraits* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const TestConflictingSymbolNames_TypeTraits& from);
  void MergeFrom(const TestConflictingSymbolNames_TypeTraits& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestConflictingSymbolNames.TypeTraits)
 private:
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[1];
  
  friend void  protobuf_AddDesc_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto();
  friend void protobuf_AssignDesc_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto();
  friend void protobuf_ShutdownFile_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto();
  
  void InitAsDefaultInstance();
  static TestConflictingSymbolNames_TypeTraits* default_instance_;
};
// -------------------------------------------------------------------

class TestConflictingSymbolNames_Data1 : public ::google::protobuf::Message {
 public:
  TestConflictingSymbolNames_Data1();
  virtual ~TestConflictingSymbolNames_Data1();
  
  TestConflictingSymbolNames_Data1(const TestConflictingSymbolNames_Data1& from);
  
  inline TestConflictingSymbolNames_Data1& operator=(const TestConflictingSymbolNames_Data1& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const TestConflictingSymbolNames_Data1& default_instance();
  
  void Swap(TestConflictingSymbolNames_Data1* other);
  
  // implements Message ----------------------------------------------
  
  TestConflictingSymbolNames_Data1* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const TestConflictingSymbolNames_Data1& from);
  void MergeFrom(const TestConflictingSymbolNames_Data1& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // repeated int32 data = 1;
  inline int data_size() const;
  inline void clear_data();
  static const int kDataFieldNumber = 1;
  inline ::google::protobuf::int32 data(int index) const;
  inline void set_data(int index, ::google::protobuf::int32 value);
  inline void add_data(::google::protobuf::int32 value);
  inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
      data() const;
  inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
      mutable_data();
  
  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestConflictingSymbolNames.Data1)
 private:
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > data_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
  
  friend void  protobuf_AddDesc_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto();
  friend void protobuf_AssignDesc_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto();
  friend void protobuf_ShutdownFile_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto();
  
  void InitAsDefaultInstance();
  static TestConflictingSymbolNames_Data1* default_instance_;
};
// -------------------------------------------------------------------

class TestConflictingSymbolNames_Data2 : public ::google::protobuf::Message {
 public:
  TestConflictingSymbolNames_Data2();
  virtual ~TestConflictingSymbolNames_Data2();
  
  TestConflictingSymbolNames_Data2(const TestConflictingSymbolNames_Data2& from);
  
  inline TestConflictingSymbolNames_Data2& operator=(const TestConflictingSymbolNames_Data2& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const TestConflictingSymbolNames_Data2& default_instance();
  
  void Swap(TestConflictingSymbolNames_Data2* other);
  
  // implements Message ----------------------------------------------
  
  TestConflictingSymbolNames_Data2* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const TestConflictingSymbolNames_Data2& from);
  void MergeFrom(const TestConflictingSymbolNames_Data2& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // repeated .protobuf_unittest.TestConflictingSymbolNames.TestEnum data = 1;
  inline int data_size() const;
  inline void clear_data();
  static const int kDataFieldNumber = 1;
  inline ::protobuf_unittest::TestConflictingSymbolNames_TestEnum data(int index) const;
  inline void set_data(int index, ::protobuf_unittest::TestConflictingSymbolNames_TestEnum value);
  inline void add_data(::protobuf_unittest::TestConflictingSymbolNames_TestEnum value);
  inline const ::google::protobuf::RepeatedField<int>& data() const;
  inline ::google::protobuf::RepeatedField<int>* mutable_data();
  
  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestConflictingSymbolNames.Data2)
 private:
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::google::protobuf::RepeatedField<int> data_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
  
  friend void  protobuf_AddDesc_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto();
  friend void protobuf_AssignDesc_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto();
  friend void protobuf_ShutdownFile_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto();
  
  void InitAsDefaultInstance();
  static TestConflictingSymbolNames_Data2* default_instance_;
};
// -------------------------------------------------------------------

class TestConflictingSymbolNames_Data3 : public ::google::protobuf::Message {
 public:
  TestConflictingSymbolNames_Data3();
  virtual ~TestConflictingSymbolNames_Data3();
  
  TestConflictingSymbolNames_Data3(const TestConflictingSymbolNames_Data3& from);
  
  inline TestConflictingSymbolNames_Data3& operator=(const TestConflictingSymbolNames_Data3& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const TestConflictingSymbolNames_Data3& default_instance();
  
  void Swap(TestConflictingSymbolNames_Data3* other);
  
  // implements Message ----------------------------------------------
  
  TestConflictingSymbolNames_Data3* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const TestConflictingSymbolNames_Data3& from);
  void MergeFrom(const TestConflictingSymbolNames_Data3& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // repeated string data = 1;
  inline int data_size() const;
  inline void clear_data();
  static const int kDataFieldNumber = 1;
  inline const ::std::string& data(int index) const;
  inline ::std::string* mutable_data(int index);
  inline void set_data(int index, const ::std::string& value);
  inline void set_data(int index, const char* value);
  inline void set_data(int index, const char* value, size_t size);
  inline ::std::string* add_data();
  inline void add_data(const ::std::string& value);
  inline void add_data(const char* value);
  inline void add_data(const char* value, size_t size);
  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& data() const;
  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_data();
  
  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestConflictingSymbolNames.Data3)
 private:
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::google::protobuf::RepeatedPtrField< ::std::string> data_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
  
  friend void  protobuf_AddDesc_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto();
  friend void protobuf_AssignDesc_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto();
  friend void protobuf_ShutdownFile_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto();
  
  void InitAsDefaultInstance();
  static TestConflictingSymbolNames_Data3* default_instance_;
};
// -------------------------------------------------------------------

class TestConflictingSymbolNames_Data4 : public ::google::protobuf::Message {
 public:
  TestConflictingSymbolNames_Data4();
  virtual ~TestConflictingSymbolNames_Data4();
  
  TestConflictingSymbolNames_Data4(const TestConflictingSymbolNames_Data4& from);
  
  inline TestConflictingSymbolNames_Data4& operator=(const TestConflictingSymbolNames_Data4& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const TestConflictingSymbolNames_Data4& default_instance();
  
  void Swap(TestConflictingSymbolNames_Data4* other);
  
  // implements Message ----------------------------------------------
  
  TestConflictingSymbolNames_Data4* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const TestConflictingSymbolNames_Data4& from);
  void MergeFrom(const TestConflictingSymbolNames_Data4& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // repeated .protobuf_unittest.TestConflictingSymbolNames.Data4 data = 1;
  inline int data_size() const;
  inline void clear_data();
  static const int kDataFieldNumber = 1;
  inline const ::protobuf_unittest::TestConflictingSymbolNames_Data4& data(int index) const;
  inline ::protobuf_unittest::TestConflictingSymbolNames_Data4* mutable_data(int index);
  inline ::protobuf_unittest::TestConflictingSymbolNames_Data4* add_data();
  inline const ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::TestConflictingSymbolNames_Data4 >&
      data() const;
  inline ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::TestConflictingSymbolNames_Data4 >*
      mutable_data();
  
  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestConflictingSymbolNames.Data4)
 private:
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::google::protobuf::RepeatedPtrField< ::protobuf_unittest::TestConflictingSymbolNames_Data4 > data_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
  
  friend void  protobuf_AddDesc_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto();
  friend void protobuf_AssignDesc_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto();
  friend void protobuf_ShutdownFile_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto();
  
  void InitAsDefaultInstance();
  static TestConflictingSymbolNames_Data4* default_instance_;
};
// -------------------------------------------------------------------

class TestConflictingSymbolNames_Data5 : public ::google::protobuf::Message {
 public:
  TestConflictingSymbolNames_Data5();
  virtual ~TestConflictingSymbolNames_Data5();
  
  TestConflictingSymbolNames_Data5(const TestConflictingSymbolNames_Data5& from);
  
  inline TestConflictingSymbolNames_Data5& operator=(const TestConflictingSymbolNames_Data5& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const TestConflictingSymbolNames_Data5& default_instance();
  
  void Swap(TestConflictingSymbolNames_Data5* other);
  
  // implements Message ----------------------------------------------
  
  TestConflictingSymbolNames_Data5* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const TestConflictingSymbolNames_Data5& from);
  void MergeFrom(const TestConflictingSymbolNames_Data5& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // repeated string data = 1 [ctype = STRING_PIECE];
  inline int data_size() const;
  inline void clear_data();
  static const int kDataFieldNumber = 1;
 private:
  // Hidden due to unknown ctype option.
  inline const ::std::string& data(int index) const;
  inline ::std::string* mutable_data(int index);
  inline void set_data(int index, const ::std::string& value);
  inline void set_data(int index, const char* value);
  inline void set_data(int index, const char* value, size_t size);
  inline ::std::string* add_data();
  inline void add_data(const ::std::string& value);
  inline void add_data(const char* value);
  inline void add_data(const char* value, size_t size);
  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& data() const;
  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_data();
 public:
  
  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestConflictingSymbolNames.Data5)
 private:
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::google::protobuf::RepeatedPtrField< ::std::string> data_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
  
  friend void  protobuf_AddDesc_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto();
  friend void protobuf_AssignDesc_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto();
  friend void protobuf_ShutdownFile_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto();
  
  void InitAsDefaultInstance();
  static TestConflictingSymbolNames_Data5* default_instance_;
};
// -------------------------------------------------------------------

class TestConflictingSymbolNames_Data6 : public ::google::protobuf::Message {
 public:
  TestConflictingSymbolNames_Data6();
  virtual ~TestConflictingSymbolNames_Data6();
  
  TestConflictingSymbolNames_Data6(const TestConflictingSymbolNames_Data6& from);
  
  inline TestConflictingSymbolNames_Data6& operator=(const TestConflictingSymbolNames_Data6& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const TestConflictingSymbolNames_Data6& default_instance();
  
  void Swap(TestConflictingSymbolNames_Data6* other);
  
  // implements Message ----------------------------------------------
  
  TestConflictingSymbolNames_Data6* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const TestConflictingSymbolNames_Data6& from);
  void MergeFrom(const TestConflictingSymbolNames_Data6& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // repeated string data = 1 [ctype = CORD];
  inline int data_size() const;
  inline void clear_data();
  static const int kDataFieldNumber = 1;
 private:
  // Hidden due to unknown ctype option.
  inline const ::std::string& data(int index) const;
  inline ::std::string* mutable_data(int index);
  inline void set_data(int index, const ::std::string& value);
  inline void set_data(int index, const char* value);
  inline void set_data(int index, const char* value, size_t size);
  inline ::std::string* add_data();
  inline void add_data(const ::std::string& value);
  inline void add_data(const char* value);
  inline void add_data(const char* value, size_t size);
  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& data() const;
  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_data();
 public:
  
  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestConflictingSymbolNames.Data6)
 private:
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::google::protobuf::RepeatedPtrField< ::std::string> data_;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
  
  friend void  protobuf_AddDesc_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto();
  friend void protobuf_AssignDesc_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto();
  friend void protobuf_ShutdownFile_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto();
  
  void InitAsDefaultInstance();
  static TestConflictingSymbolNames_Data6* default_instance_;
};
// -------------------------------------------------------------------

class TestConflictingSymbolNames_Cord : public ::google::protobuf::Message {
 public:
  TestConflictingSymbolNames_Cord();
  virtual ~TestConflictingSymbolNames_Cord();
  
  TestConflictingSymbolNames_Cord(const TestConflictingSymbolNames_Cord& from);
  
  inline TestConflictingSymbolNames_Cord& operator=(const TestConflictingSymbolNames_Cord& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const TestConflictingSymbolNames_Cord& default_instance();
  
  void Swap(TestConflictingSymbolNames_Cord* other);
  
  // implements Message ----------------------------------------------
  
  TestConflictingSymbolNames_Cord* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const TestConflictingSymbolNames_Cord& from);
  void MergeFrom(const TestConflictingSymbolNames_Cord& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestConflictingSymbolNames.Cord)
 private:
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[1];
  
  friend void  protobuf_AddDesc_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto();
  friend void protobuf_AssignDesc_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto();
  friend void protobuf_ShutdownFile_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto();
  
  void InitAsDefaultInstance();
  static TestConflictingSymbolNames_Cord* default_instance_;
};
// -------------------------------------------------------------------

class TestConflictingSymbolNames_StringPiece : public ::google::protobuf::Message {
 public:
  TestConflictingSymbolNames_StringPiece();
  virtual ~TestConflictingSymbolNames_StringPiece();
  
  TestConflictingSymbolNames_StringPiece(const TestConflictingSymbolNames_StringPiece& from);
  
  inline TestConflictingSymbolNames_StringPiece& operator=(const TestConflictingSymbolNames_StringPiece& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const TestConflictingSymbolNames_StringPiece& default_instance();
  
  void Swap(TestConflictingSymbolNames_StringPiece* other);
  
  // implements Message ----------------------------------------------
  
  TestConflictingSymbolNames_StringPiece* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const TestConflictingSymbolNames_StringPiece& from);
  void MergeFrom(const TestConflictingSymbolNames_StringPiece& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestConflictingSymbolNames.StringPiece)
 private:
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[1];
  
  friend void  protobuf_AddDesc_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto();
  friend void protobuf_AssignDesc_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto();
  friend void protobuf_ShutdownFile_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto();
  
  void InitAsDefaultInstance();
  static TestConflictingSymbolNames_StringPiece* default_instance_;
};
// -------------------------------------------------------------------

class TestConflictingSymbolNames_DO : public ::google::protobuf::Message {
 public:
  TestConflictingSymbolNames_DO();
  virtual ~TestConflictingSymbolNames_DO();
  
  TestConflictingSymbolNames_DO(const TestConflictingSymbolNames_DO& from);
  
  inline TestConflictingSymbolNames_DO& operator=(const TestConflictingSymbolNames_DO& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const TestConflictingSymbolNames_DO& default_instance();
  
  void Swap(TestConflictingSymbolNames_DO* other);
  
  // implements Message ----------------------------------------------
  
  TestConflictingSymbolNames_DO* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const TestConflictingSymbolNames_DO& from);
  void MergeFrom(const TestConflictingSymbolNames_DO& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestConflictingSymbolNames.DO)
 private:
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[1];
  
  friend void  protobuf_AddDesc_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto();
  friend void protobuf_AssignDesc_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto();
  friend void protobuf_ShutdownFile_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto();
  
  void InitAsDefaultInstance();
  static TestConflictingSymbolNames_DO* default_instance_;
};
// -------------------------------------------------------------------

class TestConflictingSymbolNames : public ::google::protobuf::Message {
 public:
  TestConflictingSymbolNames();
  virtual ~TestConflictingSymbolNames();
  
  TestConflictingSymbolNames(const TestConflictingSymbolNames& from);
  
  inline TestConflictingSymbolNames& operator=(const TestConflictingSymbolNames& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const TestConflictingSymbolNames& default_instance();
  
  void Swap(TestConflictingSymbolNames* other);
  
  // implements Message ----------------------------------------------
  
  TestConflictingSymbolNames* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const TestConflictingSymbolNames& from);
  void MergeFrom(const TestConflictingSymbolNames& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  typedef TestConflictingSymbolNames_BuildDescriptors BuildDescriptors;
  typedef TestConflictingSymbolNames_TypeTraits TypeTraits;
  typedef TestConflictingSymbolNames_Data1 Data1;
  typedef TestConflictingSymbolNames_Data2 Data2;
  typedef TestConflictingSymbolNames_Data3 Data3;
  typedef TestConflictingSymbolNames_Data4 Data4;
  typedef TestConflictingSymbolNames_Data5 Data5;
  typedef TestConflictingSymbolNames_Data6 Data6;
  typedef TestConflictingSymbolNames_Cord Cord;
  typedef TestConflictingSymbolNames_StringPiece StringPiece;
  typedef TestConflictingSymbolNames_DO DO;
  
  typedef TestConflictingSymbolNames_TestEnum TestEnum;
  static const TestEnum FOO = TestConflictingSymbolNames_TestEnum_FOO;
  static inline bool TestEnum_IsValid(int value) {
    return TestConflictingSymbolNames_TestEnum_IsValid(value);
  }
  static const TestEnum TestEnum_MIN =
    TestConflictingSymbolNames_TestEnum_TestEnum_MIN;
  static const TestEnum TestEnum_MAX =
    TestConflictingSymbolNames_TestEnum_TestEnum_MAX;
  static const int TestEnum_ARRAYSIZE =
    TestConflictingSymbolNames_TestEnum_TestEnum_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  TestEnum_descriptor() {
    return TestConflictingSymbolNames_TestEnum_descriptor();
  }
  static inline const ::std::string& TestEnum_Name(TestEnum value) {
    return TestConflictingSymbolNames_TestEnum_Name(value);
  }
  static inline bool TestEnum_Parse(const ::std::string& name,
      TestEnum* value) {
    return TestConflictingSymbolNames_TestEnum_Parse(name, value);
  }
  
  // accessors -------------------------------------------------------
  
  // optional int32 input = 1;
  inline bool has_input() const;
  inline void clear_input();
  static const int kInputFieldNumber = 1;
  inline ::google::protobuf::int32 input() const;
  inline void set_input(::google::protobuf::int32 value);
  
  // optional int32 output = 2;
  inline bool has_output() const;
  inline void clear_output();
  static const int kOutputFieldNumber = 2;
  inline ::google::protobuf::int32 output() const;
  inline void set_output(::google::protobuf::int32 value);
  
  // optional string length = 3;
  inline bool has_length() const;
  inline void clear_length();
  static const int kLengthFieldNumber = 3;
  inline const ::std::string& length() const;
  inline void set_length(const ::std::string& value);
  inline void set_length(const char* value);
  inline void set_length(const char* value, size_t size);
  inline ::std::string* mutable_length();
  inline ::std::string* release_length();
  
  // repeated int32 i = 4;
  inline int i_size() const;
  inline void clear_i();
  static const int kIFieldNumber = 4;
  inline ::google::protobuf::int32 i(int index) const;
  inline void set_i(int index, ::google::protobuf::int32 value);
  inline void add_i(::google::protobuf::int32 value);
  inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
      i() const;
  inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
      mutable_i();
  
  // repeated string new_element = 5 [ctype = STRING_PIECE];
  inline int new_element_size() const;
  inline void clear_new_element();
  static const int kNewElementFieldNumber = 5;
 private:
  // Hidden due to unknown ctype option.
  inline const ::std::string& new_element(int index) const;
  inline ::std::string* mutable_new_element(int index);
  inline void set_new_element(int index, const ::std::string& value);
  inline void set_new_element(int index, const char* value);
  inline void set_new_element(int index, const char* value, size_t size);
  inline ::std::string* add_new_element();
  inline void add_new_element(const ::std::string& value);
  inline void add_new_element(const char* value);
  inline void add_new_element(const char* value, size_t size);
  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& new_element() const;
  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_new_element();
 public:
  
  // optional int32 total_size = 6;
  inline bool has_total_size() const;
  inline void clear_total_size();
  static const int kTotalSizeFieldNumber = 6;
  inline ::google::protobuf::int32 total_size() const;
  inline void set_total_size(::google::protobuf::int32 value);
  
  // optional int32 tag = 7;
  inline bool has_tag() const;
  inline void clear_tag();
  static const int kTagFieldNumber = 7;
  inline ::google::protobuf::int32 tag() const;
  inline void set_tag(::google::protobuf::int32 value);
  
  // optional int32 source = 8;
  inline bool has_source() const;
  inline void clear_source();
  static const int kSourceFieldNumber = 8;
  inline ::google::protobuf::int32 source() const;
  inline void set_source(::google::protobuf::int32 value);
  
  // optional int32 value = 9;
  inline bool has_value() const;
  inline void clear_value();
  static const int kValueFieldNumber = 9;
  inline ::google::protobuf::int32 value() const;
  inline void set_value(::google::protobuf::int32 value);
  
  // optional int32 file = 10;
  inline bool has_file() const;
  inline void clear_file();
  static const int kFileFieldNumber = 10;
  inline ::google::protobuf::int32 file() const;
  inline void set_file(::google::protobuf::int32 value);
  
  // optional int32 from = 11;
  inline bool has_from() const;
  inline void clear_from();
  static const int kFromFieldNumber = 11;
  inline ::google::protobuf::int32 from() const;
  inline void set_from(::google::protobuf::int32 value);
  
  // optional int32 handle_uninterpreted = 12;
  inline bool has_handle_uninterpreted() const;
  inline void clear_handle_uninterpreted();
  static const int kHandleUninterpretedFieldNumber = 12;
  inline ::google::protobuf::int32 handle_uninterpreted() const;
  inline void set_handle_uninterpreted(::google::protobuf::int32 value);
  
  // repeated int32 index = 13;
  inline int index_size() const;
  inline void clear_index();
  static const int kIndexFieldNumber = 13;
  inline ::google::protobuf::int32 index(int index) const;
  inline void set_index(int index, ::google::protobuf::int32 value);
  inline void add_index(::google::protobuf::int32 value);
  inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
      index() const;
  inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
      mutable_index();
  
  // optional int32 controller = 14;
  inline bool has_controller() const;
  inline void clear_controller();
  static const int kControllerFieldNumber = 14;
  inline ::google::protobuf::int32 controller() const;
  inline void set_controller(::google::protobuf::int32 value);
  
  // optional int32 already_here = 15;
  inline bool has_already_here() const;
  inline void clear_already_here();
  static const int kAlreadyHereFieldNumber = 15;
  inline ::google::protobuf::int32 already_here() const;
  inline void set_already_here(::google::protobuf::int32 value);
  
  // optional uint32 uint32 = 16;
  inline bool has_uint32() const;
  inline void clear_uint32();
  static const int kUint32FieldNumber = 16;
  inline ::google::protobuf::uint32 uint32() const;
  inline void set_uint32(::google::protobuf::uint32 value);
  
  // optional uint64 uint64 = 17;
  inline bool has_uint64() const;
  inline void clear_uint64();
  static const int kUint64FieldNumber = 17;
  inline ::google::protobuf::uint64 uint64() const;
  inline void set_uint64(::google::protobuf::uint64 value);
  
  // optional string string = 18;
  inline bool has_string() const;
  inline void clear_string();
  static const int kStringFieldNumber = 18;
  inline const ::std::string& string() const;
  inline void set_string(const ::std::string& value);
  inline void set_string(const char* value);
  inline void set_string(const char* value, size_t size);
  inline ::std::string* mutable_string();
  inline ::std::string* release_string();
  
  // optional int32 memset = 19;
  inline bool has_memset() const;
  inline void clear_memset();
  static const int kMemsetFieldNumber = 19;
  inline ::google::protobuf::int32 memset() const;
  inline void set_memset(::google::protobuf::int32 value);
  
  // optional int32 int32 = 20;
  inline bool has_int32() const;
  inline void clear_int32();
  static const int kInt32FieldNumber = 20;
  inline ::google::protobuf::int32 int32() const;
  inline void set_int32(::google::protobuf::int32 value);
  
  // optional int64 int64 = 21;
  inline bool has_int64() const;
  inline void clear_int64();
  static const int kInt64FieldNumber = 21;
  inline ::google::protobuf::int64 int64() const;
  inline void set_int64(::google::protobuf::int64 value);
  
  // optional uint32 cached_size = 22;
  inline bool has_cached_size() const;
  inline void clear_cached_size();
  static const int kCachedSizeFieldNumber = 22;
  inline ::google::protobuf::uint32 cached_size() const;
  inline void set_cached_size(::google::protobuf::uint32 value);
  
  // optional uint32 extensions = 23;
  inline bool has_extensions() const;
  inline void clear_extensions();
  static const int kExtensionsFieldNumber = 23;
  inline ::google::protobuf::uint32 extensions() const;
  inline void set_extensions(::google::protobuf::uint32 value);
  
  // optional uint32 bit = 24;
  inline bool has_bit() const;
  inline void clear_bit();
  static const int kBitFieldNumber = 24;
  inline ::google::protobuf::uint32 bit() const;
  inline void set_bit(::google::protobuf::uint32 value);
  
  // optional uint32 bits = 25;
  inline bool has_bits() const;
  inline void clear_bits();
  static const int kBitsFieldNumber = 25;
  inline ::google::protobuf::uint32 bits() const;
  inline void set_bits(::google::protobuf::uint32 value);
  
  // optional uint32 offsets = 26;
  inline bool has_offsets() const;
  inline void clear_offsets();
  static const int kOffsetsFieldNumber = 26;
  inline ::google::protobuf::uint32 offsets() const;
  inline void set_offsets(::google::protobuf::uint32 value);
  
  // optional uint32 reflection = 27;
  inline bool has_reflection() const;
  inline void clear_reflection();
  static const int kReflectionFieldNumber = 27;
  inline ::google::protobuf::uint32 reflection() const;
  inline void set_reflection(::google::protobuf::uint32 value);
  
  // optional string some_cord = 28 [ctype = CORD];
  inline bool has_some_cord() const;
  inline void clear_some_cord();
  static const int kSomeCordFieldNumber = 28;
 private:
  // Hidden due to unknown ctype option.
  inline const ::std::string& some_cord() const;
  inline void set_some_cord(const ::std::string& value);
  inline void set_some_cord(const char* value);
  inline void set_some_cord(const char* value, size_t size);
  inline ::std::string* mutable_some_cord();
  inline ::std::string* release_some_cord();
 public:
  
  // optional string some_string_piece = 29 [ctype = STRING_PIECE];
  inline bool has_some_string_piece() const;
  inline void clear_some_string_piece();
  static const int kSomeStringPieceFieldNumber = 29;
 private:
  // Hidden due to unknown ctype option.
  inline const ::std::string& some_string_piece() const;
  inline void set_some_string_piece(const ::std::string& value);
  inline void set_some_string_piece(const char* value);
  inline void set_some_string_piece(const char* value, size_t size);
  inline ::std::string* mutable_some_string_piece();
  inline ::std::string* release_some_string_piece();
 public:
  
  // optional uint32 int = 30;
  inline bool has_int_() const;
  inline void clear_int_();
  static const int kIntFieldNumber = 30;
  inline ::google::protobuf::uint32 int_() const;
  inline void set_int_(::google::protobuf::uint32 value);
  
  // optional uint32 friend = 31;
  inline bool has_friend_() const;
  inline void clear_friend_();
  static const int kFriendFieldNumber = 31;
  inline ::google::protobuf::uint32 friend_() const;
  inline void set_friend_(::google::protobuf::uint32 value);
  
  // optional .protobuf_unittest.TestConflictingSymbolNames.DO do = 32;
  inline bool has_do_() const;
  inline void clear_do_();
  static const int kDoFieldNumber = 32;
  inline const ::protobuf_unittest::TestConflictingSymbolNames_DO& do_() const;
  inline ::protobuf_unittest::TestConflictingSymbolNames_DO* mutable_do_();
  inline ::protobuf_unittest::TestConflictingSymbolNames_DO* release_do_();
  
  GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(TestConflictingSymbolNames)
  // @@protoc_insertion_point(class_scope:protobuf_unittest.TestConflictingSymbolNames)
 private:
  inline void set_has_input();
  inline void clear_has_input();
  inline void set_has_output();
  inline void clear_has_output();
  inline void set_has_length();
  inline void clear_has_length();
  inline void set_has_total_size();
  inline void clear_has_total_size();
  inline void set_has_tag();
  inline void clear_has_tag();
  inline void set_has_source();
  inline void clear_has_source();
  inline void set_has_value();
  inline void clear_has_value();
  inline void set_has_file();
  inline void clear_has_file();
  inline void set_has_from();
  inline void clear_has_from();
  inline void set_has_handle_uninterpreted();
  inline void clear_has_handle_uninterpreted();
  inline void set_has_controller();
  inline void clear_has_controller();
  inline void set_has_already_here();
  inline void clear_has_already_here();
  inline void set_has_uint32();
  inline void clear_has_uint32();
  inline void set_has_uint64();
  inline void clear_has_uint64();
  inline void set_has_string();
  inline void clear_has_string();
  inline void set_has_memset();
  inline void clear_has_memset();
  inline void set_has_int32();
  inline void clear_has_int32();
  inline void set_has_int64();
  inline void clear_has_int64();
  inline void set_has_cached_size();
  inline void clear_has_cached_size();
  inline void set_has_extensions();
  inline void clear_has_extensions();
  inline void set_has_bit();
  inline void clear_has_bit();
  inline void set_has_bits();
  inline void clear_has_bits();
  inline void set_has_offsets();
  inline void clear_has_offsets();
  inline void set_has_reflection();
  inline void clear_has_reflection();
  inline void set_has_some_cord();
  inline void clear_has_some_cord();
  inline void set_has_some_string_piece();
  inline void clear_has_some_string_piece();
  inline void set_has_int_();
  inline void clear_has_int_();
  inline void set_has_friend_();
  inline void clear_has_friend_();
  inline void set_has_do_();
  inline void clear_has_do_();
  
  ::google::protobuf::internal::ExtensionSet _extensions_;
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  ::google::protobuf::int32 input_;
  ::google::protobuf::int32 output_;
  ::std::string* length_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > i_;
  ::google::protobuf::RepeatedPtrField< ::std::string> new_element_;
  ::google::protobuf::int32 total_size_;
  ::google::protobuf::int32 tag_;
  ::google::protobuf::int32 source_;
  ::google::protobuf::int32 value_;
  ::google::protobuf::int32 file_;
  ::google::protobuf::int32 from_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > index_;
  ::google::protobuf::int32 handle_uninterpreted_;
  ::google::protobuf::int32 controller_;
  ::google::protobuf::int32 already_here_;
  ::google::protobuf::uint32 uint32_;
  ::google::protobuf::uint64 uint64_;
  ::std::string* string_;
  ::google::protobuf::int32 memset_;
  ::google::protobuf::int32 int32_;
  ::google::protobuf::int64 int64_;
  ::google::protobuf::uint32 cached_size_;
  ::google::protobuf::uint32 extensions_;
  ::google::protobuf::uint32 bit_;
  ::google::protobuf::uint32 bits_;
  ::google::protobuf::uint32 offsets_;
  ::google::protobuf::uint32 reflection_;
  ::std::string* some_cord_;
  ::std::string* some_string_piece_;
  ::google::protobuf::uint32 int__;
  ::google::protobuf::uint32 friend__;
  ::protobuf_unittest::TestConflictingSymbolNames_DO* do__;
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(32 + 31) / 32];
  
  friend void  protobuf_AddDesc_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto();
  friend void protobuf_AssignDesc_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto();
  friend void protobuf_ShutdownFile_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto();
  
  void InitAsDefaultInstance();
  static TestConflictingSymbolNames* default_instance_;
};
// -------------------------------------------------------------------

class DummyMessage : public ::google::protobuf::Message {
 public:
  DummyMessage();
  virtual ~DummyMessage();
  
  DummyMessage(const DummyMessage& from);
  
  inline DummyMessage& operator=(const DummyMessage& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const DummyMessage& default_instance();
  
  void Swap(DummyMessage* other);
  
  // implements Message ----------------------------------------------
  
  DummyMessage* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const DummyMessage& from);
  void MergeFrom(const DummyMessage& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // @@protoc_insertion_point(class_scope:protobuf_unittest.DummyMessage)
 private:
  
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  
  
  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[1];
  
  friend void  protobuf_AddDesc_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto();
  friend void protobuf_AssignDesc_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto();
  friend void protobuf_ShutdownFile_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto();
  
  void InitAsDefaultInstance();
  static DummyMessage* default_instance_;
};
// ===================================================================

class TestConflictingMethodNames_Stub;

class TestConflictingMethodNames : public ::google::protobuf::Service {
 protected:
  // This class should be treated as an abstract interface.
  inline TestConflictingMethodNames() {};
 public:
  virtual ~TestConflictingMethodNames();
  
  typedef TestConflictingMethodNames_Stub Stub;
  
  static const ::google::protobuf::ServiceDescriptor* descriptor();
  
  virtual void Closure(::google::protobuf::RpcController* controller,
                       const ::protobuf_unittest::DummyMessage* request,
                       ::protobuf_unittest::DummyMessage* response,
                       ::google::protobuf::Closure* done);
  
  // implements Service ----------------------------------------------
  
  const ::google::protobuf::ServiceDescriptor* GetDescriptor();
  void CallMethod(const ::google::protobuf::MethodDescriptor* method,
                  ::google::protobuf::RpcController* controller,
                  const ::google::protobuf::Message* request,
                  ::google::protobuf::Message* response,
                  ::google::protobuf::Closure* done);
  const ::google::protobuf::Message& GetRequestPrototype(
    const ::google::protobuf::MethodDescriptor* method) const;
  const ::google::protobuf::Message& GetResponsePrototype(
    const ::google::protobuf::MethodDescriptor* method) const;

 private:
  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(TestConflictingMethodNames);
};

class TestConflictingMethodNames_Stub : public TestConflictingMethodNames {
 public:
  TestConflictingMethodNames_Stub(::google::protobuf::RpcChannel* channel);
  TestConflictingMethodNames_Stub(::google::protobuf::RpcChannel* channel,
                   ::google::protobuf::Service::ChannelOwnership ownership);
  ~TestConflictingMethodNames_Stub();
  
  inline ::google::protobuf::RpcChannel* channel() { return channel_; }
  
  // implements TestConflictingMethodNames ------------------------------------------
  
  void Closure(::google::protobuf::RpcController* controller,
                       const ::protobuf_unittest::DummyMessage* request,
                       ::protobuf_unittest::DummyMessage* response,
                       ::google::protobuf::Closure* done);
 private:
  ::google::protobuf::RpcChannel* channel_;
  bool owns_channel_;
  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(TestConflictingMethodNames_Stub);
};


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


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

// TestConflictingSymbolNames_BuildDescriptors

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

// TestConflictingSymbolNames_TypeTraits

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

// TestConflictingSymbolNames_Data1

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

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

// TestConflictingSymbolNames_Data2

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

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

// TestConflictingSymbolNames_Data3

// repeated string data = 1;
inline int TestConflictingSymbolNames_Data3::data_size() const {
  return data_.size();
}
inline void TestConflictingSymbolNames_Data3::clear_data() {
  data_.Clear();
}
inline const ::std::string& TestConflictingSymbolNames_Data3::data(int index) const {
  return data_.Get(index);
}
inline ::std::string* TestConflictingSymbolNames_Data3::mutable_data(int index) {
  return data_.Mutable(index);
}
inline void TestConflictingSymbolNames_Data3::set_data(int index, const ::std::string& value) {
  data_.Mutable(index)->assign(value);
}
inline void TestConflictingSymbolNames_Data3::set_data(int index, const char* value) {
  data_.Mutable(index)->assign(value);
}
inline void TestConflictingSymbolNames_Data3::set_data(int index, const char* value, size_t size) {
  data_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
}
inline ::std::string* TestConflictingSymbolNames_Data3::add_data() {
  return data_.Add();
}
inline void TestConflictingSymbolNames_Data3::add_data(const ::std::string& value) {
  data_.Add()->assign(value);
}
inline void TestConflictingSymbolNames_Data3::add_data(const char* value) {
  data_.Add()->assign(value);
}
inline void TestConflictingSymbolNames_Data3::add_data(const char* value, size_t size) {
  data_.Add()->assign(reinterpret_cast<const char*>(value), size);
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
TestConflictingSymbolNames_Data3::data() const {
  return data_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
TestConflictingSymbolNames_Data3::mutable_data() {
  return &data_;
}

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

// TestConflictingSymbolNames_Data4

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

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

// TestConflictingSymbolNames_Data5

// repeated string data = 1 [ctype = STRING_PIECE];
inline int TestConflictingSymbolNames_Data5::data_size() const {
  return data_.size();
}
inline void TestConflictingSymbolNames_Data5::clear_data() {
  data_.Clear();
}
inline const ::std::string& TestConflictingSymbolNames_Data5::data(int index) const {
  return data_.Get(index);
}
inline ::std::string* TestConflictingSymbolNames_Data5::mutable_data(int index) {
  return data_.Mutable(index);
}
inline void TestConflictingSymbolNames_Data5::set_data(int index, const ::std::string& value) {
  data_.Mutable(index)->assign(value);
}
inline void TestConflictingSymbolNames_Data5::set_data(int index, const char* value) {
  data_.Mutable(index)->assign(value);
}
inline void TestConflictingSymbolNames_Data5::set_data(int index, const char* value, size_t size) {
  data_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
}
inline ::std::string* TestConflictingSymbolNames_Data5::add_data() {
  return data_.Add();
}
inline void TestConflictingSymbolNames_Data5::add_data(const ::std::string& value) {
  data_.Add()->assign(value);
}
inline void TestConflictingSymbolNames_Data5::add_data(const char* value) {
  data_.Add()->assign(value);
}
inline void TestConflictingSymbolNames_Data5::add_data(const char* value, size_t size) {
  data_.Add()->assign(reinterpret_cast<const char*>(value), size);
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
TestConflictingSymbolNames_Data5::data() const {
  return data_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
TestConflictingSymbolNames_Data5::mutable_data() {
  return &data_;
}

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

// TestConflictingSymbolNames_Data6

// repeated string data = 1 [ctype = CORD];
inline int TestConflictingSymbolNames_Data6::data_size() const {
  return data_.size();
}
inline void TestConflictingSymbolNames_Data6::clear_data() {
  data_.Clear();
}
inline const ::std::string& TestConflictingSymbolNames_Data6::data(int index) const {
  return data_.Get(index);
}
inline ::std::string* TestConflictingSymbolNames_Data6::mutable_data(int index) {
  return data_.Mutable(index);
}
inline void TestConflictingSymbolNames_Data6::set_data(int index, const ::std::string& value) {
  data_.Mutable(index)->assign(value);
}
inline void TestConflictingSymbolNames_Data6::set_data(int index, const char* value) {
  data_.Mutable(index)->assign(value);
}
inline void TestConflictingSymbolNames_Data6::set_data(int index, const char* value, size_t size) {
  data_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
}
inline ::std::string* TestConflictingSymbolNames_Data6::add_data() {
  return data_.Add();
}
inline void TestConflictingSymbolNames_Data6::add_data(const ::std::string& value) {
  data_.Add()->assign(value);
}
inline void TestConflictingSymbolNames_Data6::add_data(const char* value) {
  data_.Add()->assign(value);
}
inline void TestConflictingSymbolNames_Data6::add_data(const char* value, size_t size) {
  data_.Add()->assign(reinterpret_cast<const char*>(value), size);
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
TestConflictingSymbolNames_Data6::data() const {
  return data_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
TestConflictingSymbolNames_Data6::mutable_data() {
  return &data_;
}

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

// TestConflictingSymbolNames_Cord

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

// TestConflictingSymbolNames_StringPiece

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

// TestConflictingSymbolNames_DO

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

// TestConflictingSymbolNames

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

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

// optional string length = 3;
inline bool TestConflictingSymbolNames::has_length() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void TestConflictingSymbolNames::set_has_length() {
  _has_bits_[0] |= 0x00000004u;
}
inline void TestConflictingSymbolNames::clear_has_length() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void TestConflictingSymbolNames::clear_length() {
  if (length_ != &::google::protobuf::internal::kEmptyString) {
    length_->clear();
  }
  clear_has_length();
}
inline const ::std::string& TestConflictingSymbolNames::length() const {
  return *length_;
}
inline void TestConflictingSymbolNames::set_length(const ::std::string& value) {
  set_has_length();
  if (length_ == &::google::protobuf::internal::kEmptyString) {
    length_ = new ::std::string;
  }
  length_->assign(value);
}
inline void TestConflictingSymbolNames::set_length(const char* value) {
  set_has_length();
  if (length_ == &::google::protobuf::internal::kEmptyString) {
    length_ = new ::std::string;
  }
  length_->assign(value);
}
inline void TestConflictingSymbolNames::set_length(const char* value, size_t size) {
  set_has_length();
  if (length_ == &::google::protobuf::internal::kEmptyString) {
    length_ = new ::std::string;
  }
  length_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* TestConflictingSymbolNames::mutable_length() {
  set_has_length();
  if (length_ == &::google::protobuf::internal::kEmptyString) {
    length_ = new ::std::string;
  }
  return length_;
}
inline ::std::string* TestConflictingSymbolNames::release_length() {
  clear_has_length();
  if (length_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = length_;
    length_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

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

// repeated string new_element = 5 [ctype = STRING_PIECE];
inline int TestConflictingSymbolNames::new_element_size() const {
  return new_element_.size();
}
inline void TestConflictingSymbolNames::clear_new_element() {
  new_element_.Clear();
}
inline const ::std::string& TestConflictingSymbolNames::new_element(int index) const {
  return new_element_.Get(index);
}
inline ::std::string* TestConflictingSymbolNames::mutable_new_element(int index) {
  return new_element_.Mutable(index);
}
inline void TestConflictingSymbolNames::set_new_element(int index, const ::std::string& value) {
  new_element_.Mutable(index)->assign(value);
}
inline void TestConflictingSymbolNames::set_new_element(int index, const char* value) {
  new_element_.Mutable(index)->assign(value);
}
inline void TestConflictingSymbolNames::set_new_element(int index, const char* value, size_t size) {
  new_element_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
}
inline ::std::string* TestConflictingSymbolNames::add_new_element() {
  return new_element_.Add();
}
inline void TestConflictingSymbolNames::add_new_element(const ::std::string& value) {
  new_element_.Add()->assign(value);
}
inline void TestConflictingSymbolNames::add_new_element(const char* value) {
  new_element_.Add()->assign(value);
}
inline void TestConflictingSymbolNames::add_new_element(const char* value, size_t size) {
  new_element_.Add()->assign(reinterpret_cast<const char*>(value), size);
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
TestConflictingSymbolNames::new_element() const {
  return new_element_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
TestConflictingSymbolNames::mutable_new_element() {
  return &new_element_;
}

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

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

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

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

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

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

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

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

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

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

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

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

// optional string string = 18;
inline bool TestConflictingSymbolNames::has_string() const {
  return (_has_bits_[0] & 0x00020000u) != 0;
}
inline void TestConflictingSymbolNames::set_has_string() {
  _has_bits_[0] |= 0x00020000u;
}
inline void TestConflictingSymbolNames::clear_has_string() {
  _has_bits_[0] &= ~0x00020000u;
}
inline void TestConflictingSymbolNames::clear_string() {
  if (string_ != &::google::protobuf::internal::kEmptyString) {
    string_->clear();
  }
  clear_has_string();
}
inline const ::std::string& TestConflictingSymbolNames::string() const {
  return *string_;
}
inline void TestConflictingSymbolNames::set_string(const ::std::string& value) {
  set_has_string();
  if (string_ == &::google::protobuf::internal::kEmptyString) {
    string_ = new ::std::string;
  }
  string_->assign(value);
}
inline void TestConflictingSymbolNames::set_string(const char* value) {
  set_has_string();
  if (string_ == &::google::protobuf::internal::kEmptyString) {
    string_ = new ::std::string;
  }
  string_->assign(value);
}
inline void TestConflictingSymbolNames::set_string(const char* value, size_t size) {
  set_has_string();
  if (string_ == &::google::protobuf::internal::kEmptyString) {
    string_ = new ::std::string;
  }
  string_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* TestConflictingSymbolNames::mutable_string() {
  set_has_string();
  if (string_ == &::google::protobuf::internal::kEmptyString) {
    string_ = new ::std::string;
  }
  return string_;
}
inline ::std::string* TestConflictingSymbolNames::release_string() {
  clear_has_string();
  if (string_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = string_;
    string_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

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

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

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

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

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

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

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

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

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

// optional string some_cord = 28 [ctype = CORD];
inline bool TestConflictingSymbolNames::has_some_cord() const {
  return (_has_bits_[0] & 0x08000000u) != 0;
}
inline void TestConflictingSymbolNames::set_has_some_cord() {
  _has_bits_[0] |= 0x08000000u;
}
inline void TestConflictingSymbolNames::clear_has_some_cord() {
  _has_bits_[0] &= ~0x08000000u;
}
inline void TestConflictingSymbolNames::clear_some_cord() {
  if (some_cord_ != &::google::protobuf::internal::kEmptyString) {
    some_cord_->clear();
  }
  clear_has_some_cord();
}
inline const ::std::string& TestConflictingSymbolNames::some_cord() const {
  return *some_cord_;
}
inline void TestConflictingSymbolNames::set_some_cord(const ::std::string& value) {
  set_has_some_cord();
  if (some_cord_ == &::google::protobuf::internal::kEmptyString) {
    some_cord_ = new ::std::string;
  }
  some_cord_->assign(value);
}
inline void TestConflictingSymbolNames::set_some_cord(const char* value) {
  set_has_some_cord();
  if (some_cord_ == &::google::protobuf::internal::kEmptyString) {
    some_cord_ = new ::std::string;
  }
  some_cord_->assign(value);
}
inline void TestConflictingSymbolNames::set_some_cord(const char* value, size_t size) {
  set_has_some_cord();
  if (some_cord_ == &::google::protobuf::internal::kEmptyString) {
    some_cord_ = new ::std::string;
  }
  some_cord_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* TestConflictingSymbolNames::mutable_some_cord() {
  set_has_some_cord();
  if (some_cord_ == &::google::protobuf::internal::kEmptyString) {
    some_cord_ = new ::std::string;
  }
  return some_cord_;
}
inline ::std::string* TestConflictingSymbolNames::release_some_cord() {
  clear_has_some_cord();
  if (some_cord_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = some_cord_;
    some_cord_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

// optional string some_string_piece = 29 [ctype = STRING_PIECE];
inline bool TestConflictingSymbolNames::has_some_string_piece() const {
  return (_has_bits_[0] & 0x10000000u) != 0;
}
inline void TestConflictingSymbolNames::set_has_some_string_piece() {
  _has_bits_[0] |= 0x10000000u;
}
inline void TestConflictingSymbolNames::clear_has_some_string_piece() {
  _has_bits_[0] &= ~0x10000000u;
}
inline void TestConflictingSymbolNames::clear_some_string_piece() {
  if (some_string_piece_ != &::google::protobuf::internal::kEmptyString) {
    some_string_piece_->clear();
  }
  clear_has_some_string_piece();
}
inline const ::std::string& TestConflictingSymbolNames::some_string_piece() const {
  return *some_string_piece_;
}
inline void TestConflictingSymbolNames::set_some_string_piece(const ::std::string& value) {
  set_has_some_string_piece();
  if (some_string_piece_ == &::google::protobuf::internal::kEmptyString) {
    some_string_piece_ = new ::std::string;
  }
  some_string_piece_->assign(value);
}
inline void TestConflictingSymbolNames::set_some_string_piece(const char* value) {
  set_has_some_string_piece();
  if (some_string_piece_ == &::google::protobuf::internal::kEmptyString) {
    some_string_piece_ = new ::std::string;
  }
  some_string_piece_->assign(value);
}
inline void TestConflictingSymbolNames::set_some_string_piece(const char* value, size_t size) {
  set_has_some_string_piece();
  if (some_string_piece_ == &::google::protobuf::internal::kEmptyString) {
    some_string_piece_ = new ::std::string;
  }
  some_string_piece_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* TestConflictingSymbolNames::mutable_some_string_piece() {
  set_has_some_string_piece();
  if (some_string_piece_ == &::google::protobuf::internal::kEmptyString) {
    some_string_piece_ = new ::std::string;
  }
  return some_string_piece_;
}
inline ::std::string* TestConflictingSymbolNames::release_some_string_piece() {
  clear_has_some_string_piece();
  if (some_string_piece_ == &::google::protobuf::internal::kEmptyString) {
    return NULL;
  } else {
    ::std::string* temp = some_string_piece_;
    some_string_piece_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}

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

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

// optional .protobuf_unittest.TestConflictingSymbolNames.DO do = 32;
inline bool TestConflictingSymbolNames::has_do_() const {
  return (_has_bits_[0] & 0x80000000u) != 0;
}
inline void TestConflictingSymbolNames::set_has_do_() {
  _has_bits_[0] |= 0x80000000u;
}
inline void TestConflictingSymbolNames::clear_has_do_() {
  _has_bits_[0] &= ~0x80000000u;
}
inline void TestConflictingSymbolNames::clear_do_() {
  if (do__ != NULL) do__->::protobuf_unittest::TestConflictingSymbolNames_DO::Clear();
  clear_has_do_();
}
inline const ::protobuf_unittest::TestConflictingSymbolNames_DO& TestConflictingSymbolNames::do_() const {
  return do__ != NULL ? *do__ : *default_instance_->do__;
}
inline ::protobuf_unittest::TestConflictingSymbolNames_DO* TestConflictingSymbolNames::mutable_do_() {
  set_has_do_();
  if (do__ == NULL) do__ = new ::protobuf_unittest::TestConflictingSymbolNames_DO;
  return do__;
}
inline ::protobuf_unittest::TestConflictingSymbolNames_DO* TestConflictingSymbolNames::release_do_() {
  clear_has_do_();
  ::protobuf_unittest::TestConflictingSymbolNames_DO* temp = do__;
  do__ = NULL;
  return temp;
}

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

// DummyMessage


// @@protoc_insertion_point(namespace_scope)

}  // namespace protobuf_unittest

#ifndef SWIG
namespace google {
namespace protobuf {

template <>
inline const EnumDescriptor* GetEnumDescriptor< ::protobuf_unittest::TestConflictingSymbolNames_TestEnum>() {
  return ::protobuf_unittest::TestConflictingSymbolNames_TestEnum_descriptor();
}

}  // namespace google
}  // namespace protobuf
#endif  // SWIG

// @@protoc_insertion_point(global_scope)

#endif  // PROTOBUF_google_2fprotobuf_2fcompiler_2fcpp_2fcpp_5ftest_5fbad_5fidentifiers_2eproto__INCLUDED
