protobuf 1.4.2 → 2.0.0.rc1

data/ext/protobuf-2.4.1/src/google/protobuf/compiler/cpp/cpp_string_field.h

@@ -0,0 +1,104 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// http://code.google.com/p/protobuf/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+
+#ifndef GOOGLE_PROTOBUF_COMPILER_CPP_STRING_FIELD_H__
+#define GOOGLE_PROTOBUF_COMPILER_CPP_STRING_FIELD_H__
+
+#include <map>
+#include <string>
+#include <google/protobuf/compiler/cpp/cpp_field.h>
+
+namespace google {
+namespace protobuf {
+namespace compiler {
+namespace cpp {
+
+class StringFieldGenerator : public FieldGenerator {
+ public:
+  explicit StringFieldGenerator(const FieldDescriptor* descriptor);
+  ~StringFieldGenerator();
+
+  // implements FieldGenerator ---------------------------------------
+  void GeneratePrivateMembers(io::Printer* printer) const;
+  void GenerateAccessorDeclarations(io::Printer* printer) const;
+  void GenerateInlineAccessorDefinitions(io::Printer* printer) const;
+  void GenerateNonInlineAccessorDefinitions(io::Printer* printer) const;
+  void GenerateClearingCode(io::Printer* printer) const;
+  void GenerateMergingCode(io::Printer* printer) const;
+  void GenerateSwappingCode(io::Printer* printer) const;
+  void GenerateConstructorCode(io::Printer* printer) const;
+  void GenerateDestructorCode(io::Printer* printer) const;
+  void GenerateMergeFromCodedStream(io::Printer* printer) const;
+  void GenerateSerializeWithCachedSizes(io::Printer* printer) const;
+  void GenerateSerializeWithCachedSizesToArray(io::Printer* printer) const;
+  void GenerateByteSize(io::Printer* printer) const;
+
+ private:
+  const FieldDescriptor* descriptor_;
+  map<string, string> variables_;
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(StringFieldGenerator);
+};
+
+class RepeatedStringFieldGenerator : public FieldGenerator {
+ public:
+  explicit RepeatedStringFieldGenerator(const FieldDescriptor* descriptor);
+  ~RepeatedStringFieldGenerator();
+
+  // implements FieldGenerator ---------------------------------------
+  void GeneratePrivateMembers(io::Printer* printer) const;
+  void GenerateAccessorDeclarations(io::Printer* printer) const;
+  void GenerateInlineAccessorDefinitions(io::Printer* printer) const;
+  void GenerateClearingCode(io::Printer* printer) const;
+  void GenerateMergingCode(io::Printer* printer) const;
+  void GenerateSwappingCode(io::Printer* printer) const;
+  void GenerateConstructorCode(io::Printer* printer) const;
+  void GenerateMergeFromCodedStream(io::Printer* printer) const;
+  void GenerateSerializeWithCachedSizes(io::Printer* printer) const;
+  void GenerateSerializeWithCachedSizesToArray(io::Printer* printer) const;
+  void GenerateByteSize(io::Printer* printer) const;
+
+ private:
+  const FieldDescriptor* descriptor_;
+  map<string, string> variables_;
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(RepeatedStringFieldGenerator);
+};
+
+}  // namespace cpp
+}  // namespace compiler
+}  // namespace protobuf
+
+}  // namespace google
+#endif  // GOOGLE_PROTOBUF_COMPILER_CPP_STRING_FIELD_H__

data/ext/protobuf-2.4.1/src/google/protobuf/compiler/cpp/cpp_test_bad_identifiers.pb.h

@@ -0,0 +1,2721 @@
+// 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