text: // Generated by the protocol buffer compiler.  DO NOT EDIT!
  // source: test.proto
  
  #include "test.pb.h"
  
  #include <algorithm>
  
  #include <google/protobuf/io/coded_stream.h>
  #include <google/protobuf/extension_set.h>
  #include <google/protobuf/wire_format_lite.h>
  #include <google/protobuf/descriptor.h>
  #include <google/protobuf/generated_message_reflection.h>
  #include <google/protobuf/reflection_ops.h>
  #include <google/protobuf/wire_format.h>
  // @@protoc_insertion_point(includes)
  #include <google/protobuf/port_def.inc>
  extern PROTOBUF_INTERNAL_EXPORT_test_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_TestMessage_test_2eproto;
  extern PROTOBUF_INTERNAL_EXPORT_test_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_TestMessage_MapMemberEntry_DoNotUse_test_2eproto;
  namespace OuterTest {
  namespace InnerTest {
  class TestMessage_MapMemberEntry_DoNotUseDefaultTypeInternal {
   public:
    ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<TestMessage_MapMemberEntry_DoNotUse> _instance;
  } _TestMessage_MapMemberEntry_DoNotUse_default_instance_;
  class TestMessageDefaultTypeInternal {
   public:
    ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<TestMessage> _instance;
  } _TestMessage_default_instance_;
  class TestNestedMessageDefaultTypeInternal {
   public:
    ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<TestNestedMessage> _instance;
  } _TestNestedMessage_default_instance_;
  class TestRequestDefaultTypeInternal {
   public:
    ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<TestRequest> _instance;
  } _TestRequest_default_instance_;
  class TestResponseDefaultTypeInternal {
   public:
    ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<TestResponse> _instance;
  } _TestResponse_default_instance_;
  }  // namespace InnerTest
  }  // namespace OuterTest
  static void InitDefaultsscc_info_TestMessage_test_2eproto() {
    GOOGLE_PROTOBUF_VERIFY_VERSION;
  
    {
      void* ptr = &::OuterTest::InnerTest::_TestMessage_default_instance_;
      new (ptr) ::OuterTest::InnerTest::TestMessage();
      ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
    }
    ::OuterTest::InnerTest::TestMessage::InitAsDefaultInstance();
  }
  
  ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_TestMessage_test_2eproto =
      {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_TestMessage_test_2eproto}, {
        &scc_info_TestMessage_MapMemberEntry_DoNotUse_test_2eproto.base,}};
  
  static void InitDefaultsscc_info_TestMessage_MapMemberEntry_DoNotUse_test_2eproto() {
    GOOGLE_PROTOBUF_VERIFY_VERSION;
  
    {
      void* ptr = &::OuterTest::InnerTest::_TestMessage_MapMemberEntry_DoNotUse_default_instance_;
      new (ptr) ::OuterTest::InnerTest::TestMessage_MapMemberEntry_DoNotUse();
    }
    ::OuterTest::InnerTest::TestMessage_MapMemberEntry_DoNotUse::InitAsDefaultInstance();
  }
  
  ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_TestMessage_MapMemberEntry_DoNotUse_test_2eproto =
      {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_TestMessage_MapMemberEntry_DoNotUse_test_2eproto}, {}};
  
  static void InitDefaultsscc_info_TestNestedMessage_test_2eproto() {
    GOOGLE_PROTOBUF_VERIFY_VERSION;
  
    {
      void* ptr = &::OuterTest::InnerTest::_TestNestedMessage_default_instance_;
      new (ptr) ::OuterTest::InnerTest::TestNestedMessage();
      ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
    }
    ::OuterTest::InnerTest::TestNestedMessage::InitAsDefaultInstance();
  }
  
  ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_TestNestedMessage_test_2eproto =
      {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_TestNestedMessage_test_2eproto}, {
        &scc_info_TestMessage_test_2eproto.base,}};
  
  static void InitDefaultsscc_info_TestRequest_test_2eproto() {
    GOOGLE_PROTOBUF_VERIFY_VERSION;
  
    {
      void* ptr = &::OuterTest::InnerTest::_TestRequest_default_instance_;
      new (ptr) ::OuterTest::InnerTest::TestRequest();
      ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
    }
    ::OuterTest::InnerTest::TestRequest::InitAsDefaultInstance();
  }
  
  ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_TestRequest_test_2eproto =
      {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_TestRequest_test_2eproto}, {}};
  
  static void InitDefaultsscc_info_TestResponse_test_2eproto() {
    GOOGLE_PROTOBUF_VERIFY_VERSION;
  
    {
      void* ptr = &::OuterTest::InnerTest::_TestResponse_default_instance_;
      new (ptr) ::OuterTest::InnerTest::TestResponse();
      ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
    }
    ::OuterTest::InnerTest::TestResponse::InitAsDefaultInstance();
  }
  
  ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_TestResponse_test_2eproto =
      {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_TestResponse_test_2eproto}, {}};
  
  static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_test_2eproto[5];
  static constexpr ::PROTOBUF_NAMESPACE_ID::EnumDescriptor const** file_level_enum_descriptors_test_2eproto = nullptr;
  static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_test_2eproto = nullptr;
  
  const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_test_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
    PROTOBUF_FIELD_OFFSET(::OuterTest::InnerTest::TestMessage_MapMemberEntry_DoNotUse, _has_bits_),
    PROTOBUF_FIELD_OFFSET(::OuterTest::InnerTest::TestMessage_MapMemberEntry_DoNotUse, _internal_metadata_),
    ~0u,  // no _extensions_
    ~0u,  // no _oneof_case_
    ~0u,  // no _weak_field_map_
    PROTOBUF_FIELD_OFFSET(::OuterTest::InnerTest::TestMessage_MapMemberEntry_DoNotUse, key_),
    PROTOBUF_FIELD_OFFSET(::OuterTest::InnerTest::TestMessage_MapMemberEntry_DoNotUse, value_),
    0,
    1,
    PROTOBUF_FIELD_OFFSET(::OuterTest::InnerTest::TestMessage, _has_bits_),
    PROTOBUF_FIELD_OFFSET(::OuterTest::InnerTest::TestMessage, _internal_metadata_),
    ~0u,  // no _extensions_
    ~0u,  // no _oneof_case_
    ~0u,  // no _weak_field_map_
    PROTOBUF_FIELD_OFFSET(::OuterTest::InnerTest::TestMessage, string_member_),
    PROTOBUF_FIELD_OFFSET(::OuterTest::InnerTest::TestMessage, int_member_),
    PROTOBUF_FIELD_OFFSET(::OuterTest::InnerTest::TestMessage, repeated_int_member_),
    PROTOBUF_FIELD_OFFSET(::OuterTest::InnerTest::TestMessage, repeated_string_member_),
    PROTOBUF_FIELD_OFFSET(::OuterTest::InnerTest::TestMessage, map_member_),
    0,
    1,
    ~0u,
    ~0u,
    ~0u,
    PROTOBUF_FIELD_OFFSET(::OuterTest::InnerTest::TestNestedMessage, _has_bits_),
    PROTOBUF_FIELD_OFFSET(::OuterTest::InnerTest::TestNestedMessage, _internal_metadata_),
    ~0u,  // no _extensions_
    ~0u,  // no _oneof_case_
    ~0u,  // no _weak_field_map_
    PROTOBUF_FIELD_OFFSET(::OuterTest::InnerTest::TestNestedMessage, test_message_member_),
    PROTOBUF_FIELD_OFFSET(::OuterTest::InnerTest::TestNestedMessage, int_member_),
    0,
    1,
    PROTOBUF_FIELD_OFFSET(::OuterTest::InnerTest::TestRequest, _has_bits_),
    PROTOBUF_FIELD_OFFSET(::OuterTest::InnerTest::TestRequest, _internal_metadata_),
    ~0u,  // no _extensions_
    ~0u,  // no _oneof_case_
    ~0u,  // no _weak_field_map_
    PROTOBUF_FIELD_OFFSET(::OuterTest::InnerTest::TestRequest, request_id_),
    PROTOBUF_FIELD_OFFSET(::OuterTest::InnerTest::TestRequest, request_string_),
    1,
    0,
    PROTOBUF_FIELD_OFFSET(::OuterTest::InnerTest::TestResponse, _has_bits_),
    PROTOBUF_FIELD_OFFSET(::OuterTest::InnerTest::TestResponse, _internal_metadata_),
    ~0u,  // no _extensions_
    ~0u,  // no _oneof_case_
    ~0u,  // no _weak_field_map_
    PROTOBUF_FIELD_OFFSET(::OuterTest::InnerTest::TestResponse, response_id_),
    PROTOBUF_FIELD_OFFSET(::OuterTest::InnerTest::TestResponse, response_string_),
    1,
    0,
  };
  static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
    { 0, 7, sizeof(::OuterTest::InnerTest::TestMessage_MapMemberEntry_DoNotUse)},
    { 9, 19, sizeof(::OuterTest::InnerTest::TestMessage)},
    { 24, 31, sizeof(::OuterTest::InnerTest::TestNestedMessage)},
    { 33, 40, sizeof(::OuterTest::InnerTest::TestRequest)},
    { 42, 49, sizeof(::OuterTest::InnerTest::TestResponse)},
  };
  
  static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = {
    reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::OuterTest::InnerTest::_TestMessage_MapMemberEntry_DoNotUse_default_instance_),
    reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::OuterTest::InnerTest::_TestMessage_default_instance_),
    reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::OuterTest::InnerTest::_TestNestedMessage_default_instance_),
    reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::OuterTest::InnerTest::_TestRequest_default_instance_),
    reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::OuterTest::InnerTest::_TestResponse_default_instance_),
  };
  
  const char descriptor_table_protodef_test_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) =
    "\n\ntest.proto\022\023OuterTest.InnerTest\"\227\002\n\013Te"
    "stMessage\022\032\n\rstring_member\030\001 \001(\tH\000\210\001\001\022\027\n"
    "\nint_member\030\002 \001(\005H\001\210\001\001\022\033\n\023repeated_int_m"
    "ember\030\003 \003(\005\022\036\n\026repeated_string_member\030\004 "
    "\003(\t\022C\n\nmap_member\030\005 \003(\0132/.OuterTest.Inne"
    "rTest.TestMessage.MapMemberEntry\0320\n\016MapM"
    "emberEntry\022\013\n\003key\030\001 \001(\005\022\r\n\005value\030\002 \001(\t:\002"
    "8\001B\020\n\016_string_memberB\r\n\013_int_member\"\227\001\n\021"
    "TestNestedMessage\022B\n\023test_message_member"
    "\030\001 \001(\0132 .OuterTest.InnerTest.TestMessage"
    "H\000\210\001\001\022\027\n\nint_member\030\002 \001(\005H\001\210\001\001B\026\n\024_test_"
    "message_memberB\r\n\013_int_member\"e\n\013TestReq"
    "uest\022\027\n\nrequest_id\030\001 \001(\005H\000\210\001\001\022\033\n\016request"
    "_string\030\002 \001(\tH\001\210\001\001B\r\n\013_request_idB\021\n\017_re"
    "quest_string\"j\n\014TestResponse\022\030\n\013response"
    "_id\030\001 \001(\005H\000\210\001\001\022\034\n\017response_string\030\002 \001(\tH"
    "\001\210\001\001B\016\n\014_response_idB\022\n\020_response_string"
    "2e\n\016TestRPCService\022S\n\014GetSomething\022 .Out"
    "erTest.InnerTest.TestRequest\032!.OuterTest"
    ".InnerTest.TestResponseb\006proto3"
    ;
  static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_test_2eproto_deps[1] = {
  };
  static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_test_2eproto_sccs[5] = {
    &scc_info_TestMessage_test_2eproto.base,
    &scc_info_TestMessage_MapMemberEntry_DoNotUse_test_2eproto.base,
    &scc_info_TestNestedMessage_test_2eproto.base,
    &scc_info_TestRequest_test_2eproto.base,
    &scc_info_TestResponse_test_2eproto.base,
  };
  static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_test_2eproto_once;
  const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_test_2eproto = {
    false, false, descriptor_table_protodef_test_2eproto, "test.proto", 791,
    &descriptor_table_test_2eproto_once, descriptor_table_test_2eproto_sccs, descriptor_table_test_2eproto_deps, 5, 0,
    schemas, file_default_instances, TableStruct_test_2eproto::offsets,
    file_level_metadata_test_2eproto, 5, file_level_enum_descriptors_test_2eproto, file_level_service_descriptors_test_2eproto,
  };
  
  // Force running AddDescriptors() at dynamic initialization time.
  static bool dynamic_init_dummy_test_2eproto = (static_cast<void>(::PROTOBUF_NAMESPACE_ID::internal::AddDescriptors(&descriptor_table_test_2eproto)), true);
  namespace OuterTest {
  namespace InnerTest {
  
  // ===================================================================
  
  TestMessage_MapMemberEntry_DoNotUse::TestMessage_MapMemberEntry_DoNotUse() {}
  TestMessage_MapMemberEntry_DoNotUse::TestMessage_MapMemberEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
      : SuperType(arena) {}
  void TestMessage_MapMemberEntry_DoNotUse::MergeFrom(const TestMessage_MapMemberEntry_DoNotUse& other) {
    MergeFromInternal(other);
  }
  ::PROTOBUF_NAMESPACE_ID::Metadata TestMessage_MapMemberEntry_DoNotUse::GetMetadata() const {
    return GetMetadataStatic();
  }
  void TestMessage_MapMemberEntry_DoNotUse::MergeFrom(
      const ::PROTOBUF_NAMESPACE_ID::Message& other) {
    ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom(other);
  }
  
  
  // ===================================================================
  
  void TestMessage::InitAsDefaultInstance() {
  }
  class TestMessage::_Internal {
   public:
    using HasBits = decltype(std::declval<TestMessage>()._has_bits_);
    static void set_has_string_member(HasBits* has_bits) {
      (*has_bits)[0] |= 1u;
    }
    static void set_has_int_member(HasBits* has_bits) {
      (*has_bits)[0] |= 2u;
    }
  };
  
  TestMessage::TestMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena)
    : ::PROTOBUF_NAMESPACE_ID::Message(arena),
    repeated_int_member_(arena),
    repeated_string_member_(arena),
    map_member_(arena) {
    SharedCtor();
    RegisterArenaDtor(arena);
    // @@protoc_insertion_point(arena_constructor:OuterTest.InnerTest.TestMessage)
  }
  TestMessage::TestMessage(const TestMessage& from)
    : ::PROTOBUF_NAMESPACE_ID::Message(),
        _has_bits_(from._has_bits_),
        repeated_int_member_(from.repeated_int_member_),
        repeated_string_member_(from.repeated_string_member_) {
    _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
    map_member_.MergeFrom(from.map_member_);
    string_member_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
    if (from._internal_has_string_member()) {
      string_member_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_string_member(),
        GetArena());
    }
    int_member_ = from.int_member_;
    // @@protoc_insertion_point(copy_constructor:OuterTest.InnerTest.TestMessage)
  }
  
  void TestMessage::SharedCtor() {
    ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_TestMessage_test_2eproto.base);
    string_member_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
    int_member_ = 0;
  }
  
  TestMessage::~TestMessage() {
    // @@protoc_insertion_point(destructor:OuterTest.InnerTest.TestMessage)
    SharedDtor();
    _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }
  
  void TestMessage::SharedDtor() {
    GOOGLE_DCHECK(GetArena() == nullptr);
    string_member_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  
  void TestMessage::ArenaDtor(void* object) {
    TestMessage* _this = reinterpret_cast< TestMessage* >(object);
    (void)_this;
  }
  void TestMessage::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
  }
  void TestMessage::SetCachedSize(int size) const {
    _cached_size_.Set(size);
  }
  const TestMessage& TestMessage::default_instance() {
    ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_TestMessage_test_2eproto.base);
    return *internal_default_instance();
  }
  
  
  void TestMessage::Clear() {
  // @@protoc_insertion_point(message_clear_start:OuterTest.InnerTest.TestMessage)
    ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
    // Prevent compiler warnings about cached_has_bits being unused
    (void) cached_has_bits;
  
    repeated_int_member_.Clear();
    repeated_string_member_.Clear();
    map_member_.Clear();
    cached_has_bits = _has_bits_[0];
    if (cached_has_bits & 0x00000001u) {
      string_member_.ClearNonDefaultToEmpty();
    }
    int_member_ = 0;
    _has_bits_.Clear();
    _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }
  
  const char* TestMessage::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
  #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
    _Internal::HasBits has_bits{};
    ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
    while (!ctx->Done(&ptr)) {
      ::PROTOBUF_NAMESPACE_ID::uint32 tag;
      ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
      CHK_(ptr);
      switch (tag >> 3) {
        // string string_member = 1;
        case 1:
          if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
            auto str = _internal_mutable_string_member();
            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
            CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "OuterTest.InnerTest.TestMessage.string_member"));
            CHK_(ptr);
          } else goto handle_unusual;
          continue;
        // int32 int_member = 2;
        case 2:
          if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
            _Internal::set_has_int_member(&has_bits);
            int_member_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
            CHK_(ptr);
          } else goto handle_unusual;
          continue;
        // repeated int32 repeated_int_member = 3;
        case 3:
          if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
            ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt32Parser(_internal_mutable_repeated_int_member(), ptr, ctx);
            CHK_(ptr);
          } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24) {
            _internal_add_repeated_int_member(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
            CHK_(ptr);
          } else goto handle_unusual;
          continue;
        // repeated string repeated_string_member = 4;
        case 4:
          if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
            ptr -= 1;
            do {
              ptr += 1;
              auto str = _internal_add_repeated_string_member();
              ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
              CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "OuterTest.InnerTest.TestMessage.repeated_string_member"));
              CHK_(ptr);
              if (!ctx->DataAvailable(ptr)) break;
            } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr));
          } else goto handle_unusual;
          continue;
        // map<int32, string> map_member = 5;
        case 5:
          if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
            ptr -= 1;
            do {
              ptr += 1;
              ptr = ctx->ParseMessage(&map_member_, ptr);
              CHK_(ptr);
              if (!ctx->DataAvailable(ptr)) break;
            } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<42>(ptr));
          } else goto handle_unusual;
          continue;
        default: {
        handle_unusual:
          if ((tag & 7) == 4 || tag == 0) {
            ctx->SetLastTag(tag);
            goto success;
          }
          ptr = UnknownFieldParse(tag,
              _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
              ptr, ctx);
          CHK_(ptr != nullptr);
          continue;
        }
      }  // switch
    }  // while
  success:
    _has_bits_.Or(has_bits);
    return ptr;
  failure:
    ptr = nullptr;
    goto success;
  #undef CHK_
  }
  
  ::PROTOBUF_NAMESPACE_ID::uint8* TestMessage::_InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
    // @@protoc_insertion_point(serialize_to_array_start:OuterTest.InnerTest.TestMessage)
    ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
    (void) cached_has_bits;
  
    // string string_member = 1;
    if (_internal_has_string_member()) {
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
        this->_internal_string_member().data(), static_cast<int>(this->_internal_string_member().length()),
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
        "OuterTest.InnerTest.TestMessage.string_member");
      target = stream->WriteStringMaybeAliased(
          1, this->_internal_string_member(), target);
    }
  
    // int32 int_member = 2;
    if (_internal_has_int_member()) {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_int_member(), target);
    }
  
    // repeated int32 repeated_int_member = 3;
    {
      int byte_size = _repeated_int_member_cached_byte_size_.load(std::memory_order_relaxed);
      if (byte_size > 0) {
        target = stream->WriteInt32Packed(
            3, _internal_repeated_int_member(), byte_size, target);
      }
    }
  
    // repeated string repeated_string_member = 4;
    for (int i = 0, n = this->_internal_repeated_string_member_size(); i < n; i++) {
      const auto& s = this->_internal_repeated_string_member(i);
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
        s.data(), static_cast<int>(s.length()),
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
        "OuterTest.InnerTest.TestMessage.repeated_string_member");
      target = stream->WriteString(4, s, target);
    }
  
    // map<int32, string> map_member = 5;
    if (!this->_internal_map_member().empty()) {
      typedef ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int32, std::string >::const_pointer
          ConstPtr;
      typedef ::PROTOBUF_NAMESPACE_ID::internal::SortItem< ::PROTOBUF_NAMESPACE_ID::int32, ConstPtr > SortItem;
      typedef ::PROTOBUF_NAMESPACE_ID::internal::CompareByFirstField<SortItem> Less;
      struct Utf8Check {
        static void Check(ConstPtr p) {
          ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
            p->second.data(), static_cast<int>(p->second.length()),
            ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
            "OuterTest.InnerTest.TestMessage.MapMemberEntry.value");
        }
      };
  
      if (stream->IsSerializationDeterministic() &&
          this->_internal_map_member().size() > 1) {
        ::std::unique_ptr<SortItem[]> items(
            new SortItem[this->_internal_map_member().size()]);
        typedef ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int32, std::string >::size_type size_type;
        size_type n = 0;
        for (::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int32, std::string >::const_iterator
            it = this->_internal_map_member().begin();
            it != this->_internal_map_member().end(); ++it, ++n) {
          items[static_cast<ptrdiff_t>(n)] = SortItem(&*it);
        }
        ::std::sort(&items[0], &items[static_cast<ptrdiff_t>(n)], Less());
        for (size_type i = 0; i < n; i++) {
          target = TestMessage_MapMemberEntry_DoNotUse::Funcs::InternalSerialize(5, items[static_cast<ptrdiff_t>(i)].second->first, items[static_cast<ptrdiff_t>(i)].second->second, target, stream);
          Utf8Check::Check(&(*items[static_cast<ptrdiff_t>(i)].second));
        }
      } else {
        for (::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int32, std::string >::const_iterator
            it = this->_internal_map_member().begin();
            it != this->_internal_map_member().end(); ++it) {
          target = TestMessage_MapMemberEntry_DoNotUse::Funcs::InternalSerialize(5, it->first, it->second, target, stream);
          Utf8Check::Check(&(*it));
        }
      }
    }
  
    if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
          _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
    }
    // @@protoc_insertion_point(serialize_to_array_end:OuterTest.InnerTest.TestMessage)
    return target;
  }
  
  size_t TestMessage::ByteSizeLong() const {
  // @@protoc_insertion_point(message_byte_size_start:OuterTest.InnerTest.TestMessage)
    size_t total_size = 0;
  
    ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
    // Prevent compiler warnings about cached_has_bits being unused
    (void) cached_has_bits;
  
    // repeated int32 repeated_int_member = 3;
    {
      size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        Int32Size(this->repeated_int_member_);
      if (data_size > 0) {
        total_size += 1 +
          ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
              static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size));
      }
      int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size);
      _repeated_int_member_cached_byte_size_.store(cached_size,
                                      std::memory_order_relaxed);
      total_size += data_size;
    }
  
    // repeated string repeated_string_member = 4;
    total_size += 1 *
        ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(repeated_string_member_.size());
    for (int i = 0, n = repeated_string_member_.size(); i < n; i++) {
      total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        repeated_string_member_.Get(i));
    }
  
    // map<int32, string> map_member = 5;
    total_size += 1 *
        ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_map_member_size());
    for (::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int32, std::string >::const_iterator
        it = this->_internal_map_member().begin();
        it != this->_internal_map_member().end(); ++it) {
      total_size += TestMessage_MapMemberEntry_DoNotUse::Funcs::ByteSizeLong(it->first, it->second);
    }
  
    cached_has_bits = _has_bits_[0];
    if (cached_has_bits & 0x00000003u) {
      // string string_member = 1;
      if (cached_has_bits & 0x00000001u) {
        total_size += 1 +
          ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
            this->_internal_string_member());
      }
  
      // int32 int_member = 2;
      if (cached_has_bits & 0x00000002u) {
        total_size += 1 +
          ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
            this->_internal_int_member());
      }
  
    }
    if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
      return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
          _internal_metadata_, total_size, &_cached_size_);
    }
    int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
    SetCachedSize(cached_size);
    return total_size;
  }
  
  void TestMessage::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  // @@protoc_insertion_point(generalized_merge_from_start:OuterTest.InnerTest.TestMessage)
    GOOGLE_DCHECK_NE(&from, this);
    const TestMessage* source =
        ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<TestMessage>(
            &from);
    if (source == nullptr) {
    // @@protoc_insertion_point(generalized_merge_from_cast_fail:OuterTest.InnerTest.TestMessage)
      ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
    } else {
    // @@protoc_insertion_point(generalized_merge_from_cast_success:OuterTest.InnerTest.TestMessage)
      MergeFrom(*source);
    }
  }
  
  void TestMessage::MergeFrom(const TestMessage& from) {
  // @@protoc_insertion_point(class_specific_merge_from_start:OuterTest.InnerTest.TestMessage)
    GOOGLE_DCHECK_NE(&from, this);
    _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
    ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
    (void) cached_has_bits;
  
    repeated_int_member_.MergeFrom(from.repeated_int_member_);
    repeated_string_member_.MergeFrom(from.repeated_string_member_);
    map_member_.MergeFrom(from.map_member_);
    cached_has_bits = from._has_bits_[0];
    if (cached_has_bits & 0x00000003u) {
      if (cached_has_bits & 0x00000001u) {
        _internal_set_string_member(from._internal_string_member());
      }
      if (cached_has_bits & 0x00000002u) {
        int_member_ = from.int_member_;
      }
      _has_bits_[0] |= cached_has_bits;
    }
  }
  
  void TestMessage::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  // @@protoc_insertion_point(generalized_copy_from_start:OuterTest.InnerTest.TestMessage)
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  void TestMessage::CopyFrom(const TestMessage& from) {
  // @@protoc_insertion_point(class_specific_copy_from_start:OuterTest.InnerTest.TestMessage)
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  bool TestMessage::IsInitialized() const {
    return true;
  }
  
  void TestMessage::InternalSwap(TestMessage* other) {
    using std::swap;
    _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
    swap(_has_bits_[0], other->_has_bits_[0]);
    repeated_int_member_.InternalSwap(&other->repeated_int_member_);
    repeated_string_member_.InternalSwap(&other->repeated_string_member_);
    map_member_.Swap(&other->map_member_);
    string_member_.Swap(&other->string_member_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
    swap(int_member_, other->int_member_);
  }
  
  ::PROTOBUF_NAMESPACE_ID::Metadata TestMessage::GetMetadata() const {
    return GetMetadataStatic();
  }
  
  
  // ===================================================================
  
  void TestNestedMessage::InitAsDefaultInstance() {
    ::OuterTest::InnerTest::_TestNestedMessage_default_instance_._instance.get_mutable()->test_message_member_ = const_cast< ::OuterTest::InnerTest::TestMessage*>(
        ::OuterTest::InnerTest::TestMessage::internal_default_instance());
  }
  class TestNestedMessage::_Internal {
   public:
    using HasBits = decltype(std::declval<TestNestedMessage>()._has_bits_);
    static const ::OuterTest::InnerTest::TestMessage& test_message_member(const TestNestedMessage* msg);
    static void set_has_test_message_member(HasBits* has_bits) {
      (*has_bits)[0] |= 1u;
    }
    static void set_has_int_member(HasBits* has_bits) {
      (*has_bits)[0] |= 2u;
    }
  };
  
  const ::OuterTest::InnerTest::TestMessage&
  TestNestedMessage::_Internal::test_message_member(const TestNestedMessage* msg) {
    return *msg->test_message_member_;
  }
  TestNestedMessage::TestNestedMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena)
    : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
    SharedCtor();
    RegisterArenaDtor(arena);
    // @@protoc_insertion_point(arena_constructor:OuterTest.InnerTest.TestNestedMessage)
  }
  TestNestedMessage::TestNestedMessage(const TestNestedMessage& from)
    : ::PROTOBUF_NAMESPACE_ID::Message(),
        _has_bits_(from._has_bits_) {
    _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
    if (from._internal_has_test_message_member()) {
      test_message_member_ = new ::OuterTest::InnerTest::TestMessage(*from.test_message_member_);
    } else {
      test_message_member_ = nullptr;
    }
    int_member_ = from.int_member_;
    // @@protoc_insertion_point(copy_constructor:OuterTest.InnerTest.TestNestedMessage)
  }
  
  void TestNestedMessage::SharedCtor() {
    ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_TestNestedMessage_test_2eproto.base);
    ::memset(&test_message_member_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&int_member_) -
        reinterpret_cast<char*>(&test_message_member_)) + sizeof(int_member_));
  }
  
  TestNestedMessage::~TestNestedMessage() {
    // @@protoc_insertion_point(destructor:OuterTest.InnerTest.TestNestedMessage)
    SharedDtor();
    _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }
  
  void TestNestedMessage::SharedDtor() {
    GOOGLE_DCHECK(GetArena() == nullptr);
    if (this != internal_default_instance()) delete test_message_member_;
  }
  
  void TestNestedMessage::ArenaDtor(void* object) {
    TestNestedMessage* _this = reinterpret_cast< TestNestedMessage* >(object);
    (void)_this;
  }
  void TestNestedMessage::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
  }
  void TestNestedMessage::SetCachedSize(int size) const {
    _cached_size_.Set(size);
  }
  const TestNestedMessage& TestNestedMessage::default_instance() {
    ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_TestNestedMessage_test_2eproto.base);
    return *internal_default_instance();
  }
  
  
  void TestNestedMessage::Clear() {
  // @@protoc_insertion_point(message_clear_start:OuterTest.InnerTest.TestNestedMessage)
    ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
    // Prevent compiler warnings about cached_has_bits being unused
    (void) cached_has_bits;
  
    cached_has_bits = _has_bits_[0];
    if (cached_has_bits & 0x00000001u) {
      if (GetArena() == nullptr && test_message_member_ != nullptr) {
        delete test_message_member_;
      }
      test_message_member_ = nullptr;
    }
    int_member_ = 0;
    _has_bits_.Clear();
    _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }
  
  const char* TestNestedMessage::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
  #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
    _Internal::HasBits has_bits{};
    ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
    while (!ctx->Done(&ptr)) {
      ::PROTOBUF_NAMESPACE_ID::uint32 tag;
      ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
      CHK_(ptr);
      switch (tag >> 3) {
        // .OuterTest.InnerTest.TestMessage test_message_member = 1;
        case 1:
          if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
            ptr = ctx->ParseMessage(_internal_mutable_test_message_member(), ptr);
            CHK_(ptr);
          } else goto handle_unusual;
          continue;
        // int32 int_member = 2;
        case 2:
          if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
            _Internal::set_has_int_member(&has_bits);
            int_member_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
            CHK_(ptr);
          } else goto handle_unusual;
          continue;
        default: {
        handle_unusual:
          if ((tag & 7) == 4 || tag == 0) {
            ctx->SetLastTag(tag);
            goto success;
          }
          ptr = UnknownFieldParse(tag,
              _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
              ptr, ctx);
          CHK_(ptr != nullptr);
          continue;
        }
      }  // switch
    }  // while
  success:
    _has_bits_.Or(has_bits);
    return ptr;
  failure:
    ptr = nullptr;
    goto success;
  #undef CHK_
  }
  
  ::PROTOBUF_NAMESPACE_ID::uint8* TestNestedMessage::_InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
    // @@protoc_insertion_point(serialize_to_array_start:OuterTest.InnerTest.TestNestedMessage)
    ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
    (void) cached_has_bits;
  
    // .OuterTest.InnerTest.TestMessage test_message_member = 1;
    if (_internal_has_test_message_member()) {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          1, _Internal::test_message_member(this), target, stream);
    }
  
    // int32 int_member = 2;
    if (_internal_has_int_member()) {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_int_member(), target);
    }
  
    if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
          _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
    }
    // @@protoc_insertion_point(serialize_to_array_end:OuterTest.InnerTest.TestNestedMessage)
    return target;
  }
  
  size_t TestNestedMessage::ByteSizeLong() const {
  // @@protoc_insertion_point(message_byte_size_start:OuterTest.InnerTest.TestNestedMessage)
    size_t total_size = 0;
  
    ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
    // Prevent compiler warnings about cached_has_bits being unused
    (void) cached_has_bits;
  
    cached_has_bits = _has_bits_[0];
    if (cached_has_bits & 0x00000003u) {
      // .OuterTest.InnerTest.TestMessage test_message_member = 1;
      if (cached_has_bits & 0x00000001u) {
        total_size += 1 +
          ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
            *test_message_member_);
      }
  
      // int32 int_member = 2;
      if (cached_has_bits & 0x00000002u) {
        total_size += 1 +
          ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
            this->_internal_int_member());
      }
  
    }
    if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
      return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
          _internal_metadata_, total_size, &_cached_size_);
    }
    int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
    SetCachedSize(cached_size);
    return total_size;
  }
  
  void TestNestedMessage::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  // @@protoc_insertion_point(generalized_merge_from_start:OuterTest.InnerTest.TestNestedMessage)
    GOOGLE_DCHECK_NE(&from, this);
    const TestNestedMessage* source =
        ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<TestNestedMessage>(
            &from);
    if (source == nullptr) {
    // @@protoc_insertion_point(generalized_merge_from_cast_fail:OuterTest.InnerTest.TestNestedMessage)
      ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
    } else {
    // @@protoc_insertion_point(generalized_merge_from_cast_success:OuterTest.InnerTest.TestNestedMessage)
      MergeFrom(*source);
    }
  }
  
  void TestNestedMessage::MergeFrom(const TestNestedMessage& from) {
  // @@protoc_insertion_point(class_specific_merge_from_start:OuterTest.InnerTest.TestNestedMessage)
    GOOGLE_DCHECK_NE(&from, this);
    _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
    ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
    (void) cached_has_bits;
  
    cached_has_bits = from._has_bits_[0];
    if (cached_has_bits & 0x00000003u) {
      if (cached_has_bits & 0x00000001u) {
        _internal_mutable_test_message_member()->::OuterTest::InnerTest::TestMessage::MergeFrom(from._internal_test_message_member());
      }
      if (cached_has_bits & 0x00000002u) {
        int_member_ = from.int_member_;
      }
      _has_bits_[0] |= cached_has_bits;
    }
  }
  
  void TestNestedMessage::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  // @@protoc_insertion_point(generalized_copy_from_start:OuterTest.InnerTest.TestNestedMessage)
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  void TestNestedMessage::CopyFrom(const TestNestedMessage& from) {
  // @@protoc_insertion_point(class_specific_copy_from_start:OuterTest.InnerTest.TestNestedMessage)
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  bool TestNestedMessage::IsInitialized() const {
    return true;
  }
  
  void TestNestedMessage::InternalSwap(TestNestedMessage* other) {
    using std::swap;
    _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
    swap(_has_bits_[0], other->_has_bits_[0]);
    ::PROTOBUF_NAMESPACE_ID::internal::memswap<
        PROTOBUF_FIELD_OFFSET(TestNestedMessage, int_member_)
        + sizeof(TestNestedMessage::int_member_)
        - PROTOBUF_FIELD_OFFSET(TestNestedMessage, test_message_member_)>(
            reinterpret_cast<char*>(&test_message_member_),
            reinterpret_cast<char*>(&other->test_message_member_));
  }
  
  ::PROTOBUF_NAMESPACE_ID::Metadata TestNestedMessage::GetMetadata() const {
    return GetMetadataStatic();
  }
  
  
  // ===================================================================
  
  void TestRequest::InitAsDefaultInstance() {
  }
  class TestRequest::_Internal {
   public:
    using HasBits = decltype(std::declval<TestRequest>()._has_bits_);
    static void set_has_request_id(HasBits* has_bits) {
      (*has_bits)[0] |= 2u;
    }
    static void set_has_request_string(HasBits* has_bits) {
      (*has_bits)[0] |= 1u;
    }
  };
  
  TestRequest::TestRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
    : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
    SharedCtor();
    RegisterArenaDtor(arena);
    // @@protoc_insertion_point(arena_constructor:OuterTest.InnerTest.TestRequest)
  }
  TestRequest::TestRequest(const TestRequest& from)
    : ::PROTOBUF_NAMESPACE_ID::Message(),
        _has_bits_(from._has_bits_) {
    _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
    request_string_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
    if (from._internal_has_request_string()) {
      request_string_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_request_string(),
        GetArena());
    }
    request_id_ = from.request_id_;
    // @@protoc_insertion_point(copy_constructor:OuterTest.InnerTest.TestRequest)
  }
  
  void TestRequest::SharedCtor() {
    ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_TestRequest_test_2eproto.base);
    request_string_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
    request_id_ = 0;
  }
  
  TestRequest::~TestRequest() {
    // @@protoc_insertion_point(destructor:OuterTest.InnerTest.TestRequest)
    SharedDtor();
    _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }
  
  void TestRequest::SharedDtor() {
    GOOGLE_DCHECK(GetArena() == nullptr);
    request_string_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  
  void TestRequest::ArenaDtor(void* object) {
    TestRequest* _this = reinterpret_cast< TestRequest* >(object);
    (void)_this;
  }
  void TestRequest::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
  }
  void TestRequest::SetCachedSize(int size) const {
    _cached_size_.Set(size);
  }
  const TestRequest& TestRequest::default_instance() {
    ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_TestRequest_test_2eproto.base);
    return *internal_default_instance();
  }
  
  
  void TestRequest::Clear() {
  // @@protoc_insertion_point(message_clear_start:OuterTest.InnerTest.TestRequest)
    ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
    // Prevent compiler warnings about cached_has_bits being unused
    (void) cached_has_bits;
  
    cached_has_bits = _has_bits_[0];
    if (cached_has_bits & 0x00000001u) {
      request_string_.ClearNonDefaultToEmpty();
    }
    request_id_ = 0;
    _has_bits_.Clear();
    _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }
  
  const char* TestRequest::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
  #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
    _Internal::HasBits has_bits{};
    ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
    while (!ctx->Done(&ptr)) {
      ::PROTOBUF_NAMESPACE_ID::uint32 tag;
      ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
      CHK_(ptr);
      switch (tag >> 3) {
        // int32 request_id = 1;
        case 1:
          if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
            _Internal::set_has_request_id(&has_bits);
            request_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
            CHK_(ptr);
          } else goto handle_unusual;
          continue;
        // string request_string = 2;
        case 2:
          if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
            auto str = _internal_mutable_request_string();
            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
            CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "OuterTest.InnerTest.TestRequest.request_string"));
            CHK_(ptr);
          } else goto handle_unusual;
          continue;
        default: {
        handle_unusual:
          if ((tag & 7) == 4 || tag == 0) {
            ctx->SetLastTag(tag);
            goto success;
          }
          ptr = UnknownFieldParse(tag,
              _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
              ptr, ctx);
          CHK_(ptr != nullptr);
          continue;
        }
      }  // switch
    }  // while
  success:
    _has_bits_.Or(has_bits);
    return ptr;
  failure:
    ptr = nullptr;
    goto success;
  #undef CHK_
  }
  
  ::PROTOBUF_NAMESPACE_ID::uint8* TestRequest::_InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
    // @@protoc_insertion_point(serialize_to_array_start:OuterTest.InnerTest.TestRequest)
    ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
    (void) cached_has_bits;
  
    // int32 request_id = 1;
    if (_internal_has_request_id()) {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_request_id(), target);
    }
  
    // string request_string = 2;
    if (_internal_has_request_string()) {
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
        this->_internal_request_string().data(), static_cast<int>(this->_internal_request_string().length()),
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
        "OuterTest.InnerTest.TestRequest.request_string");
      target = stream->WriteStringMaybeAliased(
          2, this->_internal_request_string(), target);
    }
  
    if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
          _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
    }
    // @@protoc_insertion_point(serialize_to_array_end:OuterTest.InnerTest.TestRequest)
    return target;
  }
  
  size_t TestRequest::ByteSizeLong() const {
  // @@protoc_insertion_point(message_byte_size_start:OuterTest.InnerTest.TestRequest)
    size_t total_size = 0;
  
    ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
    // Prevent compiler warnings about cached_has_bits being unused
    (void) cached_has_bits;
  
    cached_has_bits = _has_bits_[0];
    if (cached_has_bits & 0x00000003u) {
      // string request_string = 2;
      if (cached_has_bits & 0x00000001u) {
        total_size += 1 +
          ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
            this->_internal_request_string());
      }
  
      // int32 request_id = 1;
      if (cached_has_bits & 0x00000002u) {
        total_size += 1 +
          ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
            this->_internal_request_id());
      }
  
    }
    if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
      return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
          _internal_metadata_, total_size, &_cached_size_);
    }
    int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
    SetCachedSize(cached_size);
    return total_size;
  }
  
  void TestRequest::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  // @@protoc_insertion_point(generalized_merge_from_start:OuterTest.InnerTest.TestRequest)
    GOOGLE_DCHECK_NE(&from, this);
    const TestRequest* source =
        ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<TestRequest>(
            &from);
    if (source == nullptr) {
    // @@protoc_insertion_point(generalized_merge_from_cast_fail:OuterTest.InnerTest.TestRequest)
      ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
    } else {
    // @@protoc_insertion_point(generalized_merge_from_cast_success:OuterTest.InnerTest.TestRequest)
      MergeFrom(*source);
    }
  }
  
  void TestRequest::MergeFrom(const TestRequest& from) {
  // @@protoc_insertion_point(class_specific_merge_from_start:OuterTest.InnerTest.TestRequest)
    GOOGLE_DCHECK_NE(&from, this);
    _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
    ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
    (void) cached_has_bits;
  
    cached_has_bits = from._has_bits_[0];
    if (cached_has_bits & 0x00000003u) {
      if (cached_has_bits & 0x00000001u) {
        _internal_set_request_string(from._internal_request_string());
      }
      if (cached_has_bits & 0x00000002u) {
        request_id_ = from.request_id_;
      }
      _has_bits_[0] |= cached_has_bits;
    }
  }
  
  void TestRequest::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  // @@protoc_insertion_point(generalized_copy_from_start:OuterTest.InnerTest.TestRequest)
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  void TestRequest::CopyFrom(const TestRequest& from) {
  // @@protoc_insertion_point(class_specific_copy_from_start:OuterTest.InnerTest.TestRequest)
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  bool TestRequest::IsInitialized() const {
    return true;
  }
  
  void TestRequest::InternalSwap(TestRequest* other) {
    using std::swap;
    _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
    swap(_has_bits_[0], other->_has_bits_[0]);
    request_string_.Swap(&other->request_string_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
    swap(request_id_, other->request_id_);
  }
  
  ::PROTOBUF_NAMESPACE_ID::Metadata TestRequest::GetMetadata() const {
    return GetMetadataStatic();
  }
  
  
  // ===================================================================
  
  void TestResponse::InitAsDefaultInstance() {
  }
  class TestResponse::_Internal {
   public:
    using HasBits = decltype(std::declval<TestResponse>()._has_bits_);
    static void set_has_response_id(HasBits* has_bits) {
      (*has_bits)[0] |= 2u;
    }
    static void set_has_response_string(HasBits* has_bits) {
      (*has_bits)[0] |= 1u;
    }
  };
  
  TestResponse::TestResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
    : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
    SharedCtor();
    RegisterArenaDtor(arena);
    // @@protoc_insertion_point(arena_constructor:OuterTest.InnerTest.TestResponse)
  }
  TestResponse::TestResponse(const TestResponse& from)
    : ::PROTOBUF_NAMESPACE_ID::Message(),
        _has_bits_(from._has_bits_) {
    _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
    response_string_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
    if (from._internal_has_response_string()) {
      response_string_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_response_string(),
        GetArena());
    }
    response_id_ = from.response_id_;
    // @@protoc_insertion_point(copy_constructor:OuterTest.InnerTest.TestResponse)
  }
  
  void TestResponse::SharedCtor() {
    ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_TestResponse_test_2eproto.base);
    response_string_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
    response_id_ = 0;
  }
  
  TestResponse::~TestResponse() {
    // @@protoc_insertion_point(destructor:OuterTest.InnerTest.TestResponse)
    SharedDtor();
    _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }
  
  void TestResponse::SharedDtor() {
    GOOGLE_DCHECK(GetArena() == nullptr);
    response_string_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  
  void TestResponse::ArenaDtor(void* object) {
    TestResponse* _this = reinterpret_cast< TestResponse* >(object);
    (void)_this;
  }
  void TestResponse::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
  }
  void TestResponse::SetCachedSize(int size) const {
    _cached_size_.Set(size);
  }
  const TestResponse& TestResponse::default_instance() {
    ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_TestResponse_test_2eproto.base);
    return *internal_default_instance();
  }
  
  
  void TestResponse::Clear() {
  // @@protoc_insertion_point(message_clear_start:OuterTest.InnerTest.TestResponse)
    ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
    // Prevent compiler warnings about cached_has_bits being unused
    (void) cached_has_bits;
  
    cached_has_bits = _has_bits_[0];
    if (cached_has_bits & 0x00000001u) {
      response_string_.ClearNonDefaultToEmpty();
    }
    response_id_ = 0;
    _has_bits_.Clear();
    _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }
  
  const char* TestResponse::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
  #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
    _Internal::HasBits has_bits{};
    ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
    while (!ctx->Done(&ptr)) {
      ::PROTOBUF_NAMESPACE_ID::uint32 tag;
      ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
      CHK_(ptr);
      switch (tag >> 3) {
        // int32 response_id = 1;
        case 1:
          if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
            _Internal::set_has_response_id(&has_bits);
            response_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
            CHK_(ptr);
          } else goto handle_unusual;
          continue;
        // string response_string = 2;
        case 2:
          if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
            auto str = _internal_mutable_response_string();
            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
            CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "OuterTest.InnerTest.TestResponse.response_string"));
            CHK_(ptr);
          } else goto handle_unusual;
          continue;
        default: {
        handle_unusual:
          if ((tag & 7) == 4 || tag == 0) {
            ctx->SetLastTag(tag);
            goto success;
          }
          ptr = UnknownFieldParse(tag,
              _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
              ptr, ctx);
          CHK_(ptr != nullptr);
          continue;
        }
      }  // switch
    }  // while
  success:
    _has_bits_.Or(has_bits);
    return ptr;
  failure:
    ptr = nullptr;
    goto success;
  #undef CHK_
  }
  
  ::PROTOBUF_NAMESPACE_ID::uint8* TestResponse::_InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
    // @@protoc_insertion_point(serialize_to_array_start:OuterTest.InnerTest.TestResponse)
    ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
    (void) cached_has_bits;
  
    // int32 response_id = 1;
    if (_internal_has_response_id()) {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_response_id(), target);
    }
  
    // string response_string = 2;
    if (_internal_has_response_string()) {
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
        this->_internal_response_string().data(), static_cast<int>(this->_internal_response_string().length()),
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
        "OuterTest.InnerTest.TestResponse.response_string");
      target = stream->WriteStringMaybeAliased(
          2, this->_internal_response_string(), target);
    }
  
    if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
          _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
    }
    // @@protoc_insertion_point(serialize_to_array_end:OuterTest.InnerTest.TestResponse)
    return target;
  }
  
  size_t TestResponse::ByteSizeLong() const {
  // @@protoc_insertion_point(message_byte_size_start:OuterTest.InnerTest.TestResponse)
    size_t total_size = 0;
  
    ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
    // Prevent compiler warnings about cached_has_bits being unused
    (void) cached_has_bits;
  
    cached_has_bits = _has_bits_[0];
    if (cached_has_bits & 0x00000003u) {
      // string response_string = 2;
      if (cached_has_bits & 0x00000001u) {
        total_size += 1 +
          ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
            this->_internal_response_string());
      }
  
      // int32 response_id = 1;
      if (cached_has_bits & 0x00000002u) {
        total_size += 1 +
          ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
            this->_internal_response_id());
      }
  
    }
    if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
      return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
          _internal_metadata_, total_size, &_cached_size_);
    }
    int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
    SetCachedSize(cached_size);
    return total_size;
  }
  
  void TestResponse::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  // @@protoc_insertion_point(generalized_merge_from_start:OuterTest.InnerTest.TestResponse)
    GOOGLE_DCHECK_NE(&from, this);
    const TestResponse* source =
        ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<TestResponse>(
            &from);
    if (source == nullptr) {
    // @@protoc_insertion_point(generalized_merge_from_cast_fail:OuterTest.InnerTest.TestResponse)
      ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
    } else {
    // @@protoc_insertion_point(generalized_merge_from_cast_success:OuterTest.InnerTest.TestResponse)
      MergeFrom(*source);
    }
  }
  
  void TestResponse::MergeFrom(const TestResponse& from) {
  // @@protoc_insertion_point(class_specific_merge_from_start:OuterTest.InnerTest.TestResponse)
    GOOGLE_DCHECK_NE(&from, this);
    _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
    ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
    (void) cached_has_bits;
  
    cached_has_bits = from._has_bits_[0];
    if (cached_has_bits & 0x00000003u) {
      if (cached_has_bits & 0x00000001u) {
        _internal_set_response_string(from._internal_response_string());
      }
      if (cached_has_bits & 0x00000002u) {
        response_id_ = from.response_id_;
      }
      _has_bits_[0] |= cached_has_bits;
    }
  }
  
  void TestResponse::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  // @@protoc_insertion_point(generalized_copy_from_start:OuterTest.InnerTest.TestResponse)
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  void TestResponse::CopyFrom(const TestResponse& from) {
  // @@protoc_insertion_point(class_specific_copy_from_start:OuterTest.InnerTest.TestResponse)
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  bool TestResponse::IsInitialized() const {
    return true;
  }
  
  void TestResponse::InternalSwap(TestResponse* other) {
    using std::swap;
    _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
    swap(_has_bits_[0], other->_has_bits_[0]);
    response_string_.Swap(&other->response_string_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
    swap(response_id_, other->response_id_);
  }
  
  ::PROTOBUF_NAMESPACE_ID::Metadata TestResponse::GetMetadata() const {
    return GetMetadataStatic();
  }
  
  
  // @@protoc_insertion_point(namespace_scope)
  }  // namespace InnerTest
  }  // namespace OuterTest
  PROTOBUF_NAMESPACE_OPEN
  template<> PROTOBUF_NOINLINE ::OuterTest::InnerTest::TestMessage_MapMemberEntry_DoNotUse* Arena::CreateMaybeMessage< ::OuterTest::InnerTest::TestMessage_MapMemberEntry_DoNotUse >(Arena* arena) {
    return Arena::CreateMessageInternal< ::OuterTest::InnerTest::TestMessage_MapMemberEntry_DoNotUse >(arena);
  }
  template<> PROTOBUF_NOINLINE ::OuterTest::InnerTest::TestMessage* Arena::CreateMaybeMessage< ::OuterTest::InnerTest::TestMessage >(Arena* arena) {
    return Arena::CreateMessageInternal< ::OuterTest::InnerTest::TestMessage >(arena);
  }
  template<> PROTOBUF_NOINLINE ::OuterTest::InnerTest::TestNestedMessage* Arena::CreateMaybeMessage< ::OuterTest::InnerTest::TestNestedMessage >(Arena* arena) {
    return Arena::CreateMessageInternal< ::OuterTest::InnerTest::TestNestedMessage >(arena);
  }
  template<> PROTOBUF_NOINLINE ::OuterTest::InnerTest::TestRequest* Arena::CreateMaybeMessage< ::OuterTest::InnerTest::TestRequest >(Arena* arena) {
    return Arena::CreateMessageInternal< ::OuterTest::InnerTest::TestRequest >(arena);
  }
  template<> PROTOBUF_NOINLINE ::OuterTest::InnerTest::TestResponse* Arena::CreateMaybeMessage< ::OuterTest::InnerTest::TestResponse >(Arena* arena) {
    return Arena::CreateMessageInternal< ::OuterTest::InnerTest::TestResponse >(arena);
  }
  PROTOBUF_NAMESPACE_CLOSE
  
  // @@protoc_insertion_point(global_scope)
  #include <google/protobuf/port_undef.inc>
  