/*
 * Copyright (c) 2024 Huawei Device Co., Ltd.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: geocoding_data.proto

#include "geocoding_data.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/io/zero_copy_stream_impl_lite.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
extern PROTOBUF_INTERNAL_EXPORT_geocoding_5fdata_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_CountriesInfo_geocoding_5fdata_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_geocoding_5fdata_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_CountryCodeInfo_geocoding_5fdata_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_geocoding_5fdata_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_LanguageCodeInfo_geocoding_5fdata_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_geocoding_5fdata_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_PrefixesInfo_geocoding_5fdata_2eproto;
namespace i18n {
namespace phonenumbers {
class GeocodingInfoDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<GeocodingInfo> _instance;
} _GeocodingInfo_default_instance_;
class PrefixesInfoDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<PrefixesInfo> _instance;
} _PrefixesInfo_default_instance_;
class LanguageCodeInfoDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<LanguageCodeInfo> _instance;
} _LanguageCodeInfo_default_instance_;
class CountriesInfoDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<CountriesInfo> _instance;
} _CountriesInfo_default_instance_;
class CountryCodeInfoDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<CountryCodeInfo> _instance;
} _CountryCodeInfo_default_instance_;
}  // namespace phonenumbers
}  // namespace i18n
static void InitDefaultsscc_info_CountriesInfo_geocoding_5fdata_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::i18n::phonenumbers::_CountriesInfo_default_instance_;
    new (ptr) ::i18n::phonenumbers::CountriesInfo();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::i18n::phonenumbers::CountriesInfo::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_CountriesInfo_geocoding_5fdata_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_CountriesInfo_geocoding_5fdata_2eproto}, {}};

static void InitDefaultsscc_info_CountryCodeInfo_geocoding_5fdata_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::i18n::phonenumbers::_CountryCodeInfo_default_instance_;
    new (ptr) ::i18n::phonenumbers::CountryCodeInfo();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::i18n::phonenumbers::CountryCodeInfo::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_CountryCodeInfo_geocoding_5fdata_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_CountryCodeInfo_geocoding_5fdata_2eproto}, {}};

static void InitDefaultsscc_info_GeocodingInfo_geocoding_5fdata_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::i18n::phonenumbers::_GeocodingInfo_default_instance_;
    new (ptr) ::i18n::phonenumbers::GeocodingInfo();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::i18n::phonenumbers::GeocodingInfo::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<4> scc_info_GeocodingInfo_geocoding_5fdata_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 4, 0, InitDefaultsscc_info_GeocodingInfo_geocoding_5fdata_2eproto}, {
      &scc_info_PrefixesInfo_geocoding_5fdata_2eproto.base,
      &scc_info_LanguageCodeInfo_geocoding_5fdata_2eproto.base,
      &scc_info_CountriesInfo_geocoding_5fdata_2eproto.base,
      &scc_info_CountryCodeInfo_geocoding_5fdata_2eproto.base,}};

static void InitDefaultsscc_info_LanguageCodeInfo_geocoding_5fdata_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::i18n::phonenumbers::_LanguageCodeInfo_default_instance_;
    new (ptr) ::i18n::phonenumbers::LanguageCodeInfo();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::i18n::phonenumbers::LanguageCodeInfo::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_LanguageCodeInfo_geocoding_5fdata_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_LanguageCodeInfo_geocoding_5fdata_2eproto}, {}};

static void InitDefaultsscc_info_PrefixesInfo_geocoding_5fdata_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::i18n::phonenumbers::_PrefixesInfo_default_instance_;
    new (ptr) ::i18n::phonenumbers::PrefixesInfo();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::i18n::phonenumbers::PrefixesInfo::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_PrefixesInfo_geocoding_5fdata_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_PrefixesInfo_geocoding_5fdata_2eproto}, {}};

namespace i18n {
namespace phonenumbers {

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

void GeocodingInfo::InitAsDefaultInstance() {
  ::i18n::phonenumbers::_GeocodingInfo_default_instance_._instance.get_mutable()->language_code_info_ = const_cast< ::i18n::phonenumbers::LanguageCodeInfo*>(
      ::i18n::phonenumbers::LanguageCodeInfo::internal_default_instance());
  ::i18n::phonenumbers::_GeocodingInfo_default_instance_._instance.get_mutable()->country_code_info_ = const_cast< ::i18n::phonenumbers::CountryCodeInfo*>(
      ::i18n::phonenumbers::CountryCodeInfo::internal_default_instance());
}
class GeocodingInfo::_Internal {
 public:
  using HasBits = decltype(std::declval<GeocodingInfo>()._has_bits_);
  static const ::i18n::phonenumbers::LanguageCodeInfo& language_code_info(const GeocodingInfo* msg);
  static void set_has_language_code_info(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static const ::i18n::phonenumbers::CountryCodeInfo& country_code_info(const GeocodingInfo* msg);
  static void set_has_country_code_info(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static bool MissingRequiredFields(const HasBits& has_bits) {
    return ((has_bits[0] & 0x00000003) ^ 0x00000003) != 0;
  }
};

const ::i18n::phonenumbers::LanguageCodeInfo&
GeocodingInfo::_Internal::language_code_info(const GeocodingInfo* msg) {
  return *msg->language_code_info_;
}
const ::i18n::phonenumbers::CountryCodeInfo&
GeocodingInfo::_Internal::country_code_info(const GeocodingInfo* msg) {
  return *msg->country_code_info_;
}
GeocodingInfo::GeocodingInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
  prefixes_info_(arena),
  languages_(arena),
  countries_info_(arena),
  countries_(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:i18n.phonenumbers.GeocodingInfo)
}
GeocodingInfo::GeocodingInfo(const GeocodingInfo& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
      _has_bits_(from._has_bits_),
      prefixes_info_(from.prefixes_info_),
      languages_(from.languages_),
      countries_info_(from.countries_info_),
      countries_(from.countries_) {
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  if (from._internal_has_language_code_info()) {
    language_code_info_ = new ::i18n::phonenumbers::LanguageCodeInfo(*from.language_code_info_);
  } else {
    language_code_info_ = nullptr;
  }
  if (from._internal_has_country_code_info()) {
    country_code_info_ = new ::i18n::phonenumbers::CountryCodeInfo(*from.country_code_info_);
  } else {
    country_code_info_ = nullptr;
  }
  // @@protoc_insertion_point(copy_constructor:i18n.phonenumbers.GeocodingInfo)
}

void GeocodingInfo::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_GeocodingInfo_geocoding_5fdata_2eproto.base);
  ::memset(&language_code_info_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&country_code_info_) -
      reinterpret_cast<char*>(&language_code_info_)) + sizeof(country_code_info_));
}

GeocodingInfo::~GeocodingInfo() {
  // @@protoc_insertion_point(destructor:i18n.phonenumbers.GeocodingInfo)
  SharedDtor();
  _internal_metadata_.Delete<std::string>();
}

void GeocodingInfo::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
  if (this != internal_default_instance()) delete language_code_info_;
  if (this != internal_default_instance()) delete country_code_info_;
}

void GeocodingInfo::ArenaDtor(void* object) {
  GeocodingInfo* _this = reinterpret_cast< GeocodingInfo* >(object);
  (void)_this;
}
void GeocodingInfo::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void GeocodingInfo::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const GeocodingInfo& GeocodingInfo::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_GeocodingInfo_geocoding_5fdata_2eproto.base);
  return *internal_default_instance();
}


void GeocodingInfo::Clear() {
// @@protoc_insertion_point(message_clear_start:i18n.phonenumbers.GeocodingInfo)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  prefixes_info_.Clear();
  languages_.Clear();
  countries_info_.Clear();
  countries_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      GOOGLE_DCHECK(language_code_info_ != nullptr);
      language_code_info_->Clear();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(country_code_info_ != nullptr);
      country_code_info_->Clear();
    }
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<std::string>();
}

const char* GeocodingInfo::_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) {
      // repeated .i18n.phonenumbers.PrefixesInfo prefixes_info = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_prefixes_info(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
        } else goto handle_unusual;
        continue;
      // repeated string languages = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr -= 1;
          do {
            ptr += 1;
            auto str = _internal_add_languages();
            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
        } else goto handle_unusual;
        continue;
      // required .i18n.phonenumbers.LanguageCodeInfo language_code_info = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_language_code_info(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated .i18n.phonenumbers.CountriesInfo countries_info = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_countries_info(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr));
        } else goto handle_unusual;
        continue;
      // repeated int32 countries = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) {
          ptr -= 1;
          do {
            ptr += 1;
            _internal_add_countries(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<40>(ptr));
        } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt32Parser(_internal_mutable_countries(), ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // required .i18n.phonenumbers.CountryCodeInfo country_code_info = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) {
          ptr = ctx->ParseMessage(_internal_mutable_country_code_info(), 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<std::string>(),
            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* GeocodingInfo::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:i18n.phonenumbers.GeocodingInfo)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .i18n.phonenumbers.PrefixesInfo prefixes_info = 1;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_prefixes_info_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, this->_internal_prefixes_info(i), target, stream);
  }

  // repeated string languages = 2;
  for (int i = 0, n = this->_internal_languages_size(); i < n; i++) {
    const auto& s = this->_internal_languages(i);
    target = stream->WriteString(2, s, target);
  }

  cached_has_bits = _has_bits_[0];
  // required .i18n.phonenumbers.LanguageCodeInfo language_code_info = 3;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        3, _Internal::language_code_info(this), target, stream);
  }

  // repeated .i18n.phonenumbers.CountriesInfo countries_info = 4;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_countries_info_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(4, this->_internal_countries_info(i), target, stream);
  }

  // repeated int32 countries = 5;
  for (int i = 0, n = this->_internal_countries_size(); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(5, this->_internal_countries(i), target);
  }

  // required .i18n.phonenumbers.CountryCodeInfo country_code_info = 6;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        6, _Internal::country_code_info(this), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:i18n.phonenumbers.GeocodingInfo)
  return target;
}

size_t GeocodingInfo::RequiredFieldsByteSizeFallback() const {
// @@protoc_insertion_point(required_fields_byte_size_fallback_start:i18n.phonenumbers.GeocodingInfo)
  size_t total_size = 0;

  if (_internal_has_language_code_info()) {
    // required .i18n.phonenumbers.LanguageCodeInfo language_code_info = 3;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *language_code_info_);
  }

  if (_internal_has_country_code_info()) {
    // required .i18n.phonenumbers.CountryCodeInfo country_code_info = 6;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *country_code_info_);
  }

  return total_size;
}
size_t GeocodingInfo::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:i18n.phonenumbers.GeocodingInfo)
  size_t total_size = 0;

  if (((_has_bits_[0] & 0x00000003) ^ 0x00000003) == 0) {  // All required fields are present.
    // required .i18n.phonenumbers.LanguageCodeInfo language_code_info = 3;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *language_code_info_);

    // required .i18n.phonenumbers.CountryCodeInfo country_code_info = 6;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *country_code_info_);

  } else {
    total_size += RequiredFieldsByteSizeFallback();
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .i18n.phonenumbers.PrefixesInfo prefixes_info = 1;
  total_size += 1UL * this->_internal_prefixes_info_size();
  for (const auto& msg : this->prefixes_info_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // repeated string languages = 2;
  total_size += 1 *
      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(languages_.size());
  for (int i = 0, n = languages_.size(); i < n; i++) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
      languages_.Get(i));
  }

  // repeated .i18n.phonenumbers.CountriesInfo countries_info = 4;
  total_size += 1UL * this->_internal_countries_info_size();
  for (const auto& msg : this->countries_info_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // repeated int32 countries = 5;
  {
    size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      Int32Size(this->countries_);
    total_size += 1 *
                  ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_countries_size());
    total_size += data_size;
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void GeocodingInfo::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const GeocodingInfo*>(
      &from));
}

void GeocodingInfo::MergeFrom(const GeocodingInfo& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:i18n.phonenumbers.GeocodingInfo)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  prefixes_info_.MergeFrom(from.prefixes_info_);
  languages_.MergeFrom(from.languages_);
  countries_info_.MergeFrom(from.countries_info_);
  countries_.MergeFrom(from.countries_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      _internal_mutable_language_code_info()->::i18n::phonenumbers::LanguageCodeInfo::MergeFrom(from._internal_language_code_info());
    }
    if (cached_has_bits & 0x00000002u) {
      _internal_mutable_country_code_info()->::i18n::phonenumbers::CountryCodeInfo::MergeFrom(from._internal_country_code_info());
    }
  }
}

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

bool GeocodingInfo::IsInitialized() const {
  if (_Internal::MissingRequiredFields(_has_bits_)) return false;
  if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(prefixes_info_)) return false;
  if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(countries_info_)) return false;
  if (_internal_has_language_code_info()) {
    if (!language_code_info_->IsInitialized()) return false;
  }
  if (_internal_has_country_code_info()) {
    if (!country_code_info_->IsInitialized()) return false;
  }
  return true;
}

void GeocodingInfo::InternalSwap(GeocodingInfo* other) {
  using std::swap;
  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  prefixes_info_.InternalSwap(&other->prefixes_info_);
  languages_.InternalSwap(&other->languages_);
  countries_info_.InternalSwap(&other->countries_info_);
  countries_.InternalSwap(&other->countries_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(GeocodingInfo, country_code_info_)
      + sizeof(GeocodingInfo::country_code_info_)
      - PROTOBUF_FIELD_OFFSET(GeocodingInfo, language_code_info_)>(
          reinterpret_cast<char*>(&language_code_info_),
          reinterpret_cast<char*>(&other->language_code_info_));
}

std::string GeocodingInfo::GetTypeName() const {
  return "i18n.phonenumbers.GeocodingInfo";
}


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

void PrefixesInfo::InitAsDefaultInstance() {
}
class PrefixesInfo::_Internal {
 public:
  using HasBits = decltype(std::declval<PrefixesInfo>()._has_bits_);
  static void set_has_prefixes_num(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_lengths_num(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static bool MissingRequiredFields(const HasBits& has_bits) {
    return ((has_bits[0] & 0x00000003) ^ 0x00000003) != 0;
  }
};

PrefixesInfo::PrefixesInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
  prefixes_(arena),
  descriptions_(arena),
  lengths_(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:i18n.phonenumbers.PrefixesInfo)
}
PrefixesInfo::PrefixesInfo(const PrefixesInfo& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
      _has_bits_(from._has_bits_),
      prefixes_(from.prefixes_),
      descriptions_(from.descriptions_),
      lengths_(from.lengths_) {
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::memcpy(&prefixes_num_, &from.prefixes_num_,
    static_cast<size_t>(reinterpret_cast<char*>(&lengths_num_) -
    reinterpret_cast<char*>(&prefixes_num_)) + sizeof(lengths_num_));
  // @@protoc_insertion_point(copy_constructor:i18n.phonenumbers.PrefixesInfo)
}

void PrefixesInfo::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_PrefixesInfo_geocoding_5fdata_2eproto.base);
  ::memset(&prefixes_num_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&lengths_num_) -
      reinterpret_cast<char*>(&prefixes_num_)) + sizeof(lengths_num_));
}

PrefixesInfo::~PrefixesInfo() {
  // @@protoc_insertion_point(destructor:i18n.phonenumbers.PrefixesInfo)
  SharedDtor();
  _internal_metadata_.Delete<std::string>();
}

void PrefixesInfo::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
}

void PrefixesInfo::ArenaDtor(void* object) {
  PrefixesInfo* _this = reinterpret_cast< PrefixesInfo* >(object);
  (void)_this;
}
void PrefixesInfo::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void PrefixesInfo::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const PrefixesInfo& PrefixesInfo::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_PrefixesInfo_geocoding_5fdata_2eproto.base);
  return *internal_default_instance();
}


void PrefixesInfo::Clear() {
// @@protoc_insertion_point(message_clear_start:i18n.phonenumbers.PrefixesInfo)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  prefixes_.Clear();
  descriptions_.Clear();
  lengths_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    ::memset(&prefixes_num_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&lengths_num_) -
        reinterpret_cast<char*>(&prefixes_num_)) + sizeof(lengths_num_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<std::string>();
}

const char* PrefixesInfo::_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) {
      // required int32 prefixes_num = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_prefixes_num(&has_bits);
          prefixes_num_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated int32 prefixes = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          ptr -= 1;
          do {
            ptr += 1;
            _internal_add_prefixes(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<16>(ptr));
        } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt32Parser(_internal_mutable_prefixes(), ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated string descriptions = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr -= 1;
          do {
            ptr += 1;
            auto str = _internal_add_descriptions();
            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
        } else goto handle_unusual;
        continue;
      // required int32 lengths_num = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
          _Internal::set_has_lengths_num(&has_bits);
          lengths_num_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated int32 lengths = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) {
          ptr -= 1;
          do {
            ptr += 1;
            _internal_add_lengths(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<40>(ptr));
        } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt32Parser(_internal_mutable_lengths(), ptr, ctx);
          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<std::string>(),
            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* PrefixesInfo::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:i18n.phonenumbers.PrefixesInfo)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required int32 prefixes_num = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_prefixes_num(), target);
  }

  // repeated int32 prefixes = 2;
  for (int i = 0, n = this->_internal_prefixes_size(); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_prefixes(i), target);
  }

  // repeated string descriptions = 3;
  for (int i = 0, n = this->_internal_descriptions_size(); i < n; i++) {
    const auto& s = this->_internal_descriptions(i);
    target = stream->WriteString(3, s, target);
  }

  // required int32 lengths_num = 4;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(4, this->_internal_lengths_num(), target);
  }

  // repeated int32 lengths = 5;
  for (int i = 0, n = this->_internal_lengths_size(); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(5, this->_internal_lengths(i), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:i18n.phonenumbers.PrefixesInfo)
  return target;
}

size_t PrefixesInfo::RequiredFieldsByteSizeFallback() const {
// @@protoc_insertion_point(required_fields_byte_size_fallback_start:i18n.phonenumbers.PrefixesInfo)
  size_t total_size = 0;

  if (_internal_has_prefixes_num()) {
    // required int32 prefixes_num = 1;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_prefixes_num());
  }

  if (_internal_has_lengths_num()) {
    // required int32 lengths_num = 4;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_lengths_num());
  }

  return total_size;
}
size_t PrefixesInfo::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:i18n.phonenumbers.PrefixesInfo)
  size_t total_size = 0;

  if (((_has_bits_[0] & 0x00000003) ^ 0x00000003) == 0) {  // All required fields are present.
    // required int32 prefixes_num = 1;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_prefixes_num());

    // required int32 lengths_num = 4;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_lengths_num());

  } else {
    total_size += RequiredFieldsByteSizeFallback();
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated int32 prefixes = 2;
  {
    size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      Int32Size(this->prefixes_);
    total_size += 1 *
                  ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_prefixes_size());
    total_size += data_size;
  }

  // repeated string descriptions = 3;
  total_size += 1 *
      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(descriptions_.size());
  for (int i = 0, n = descriptions_.size(); i < n; i++) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
      descriptions_.Get(i));
  }

  // repeated int32 lengths = 5;
  {
    size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      Int32Size(this->lengths_);
    total_size += 1 *
                  ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_lengths_size());
    total_size += data_size;
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void PrefixesInfo::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const PrefixesInfo*>(
      &from));
}

void PrefixesInfo::MergeFrom(const PrefixesInfo& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:i18n.phonenumbers.PrefixesInfo)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  prefixes_.MergeFrom(from.prefixes_);
  descriptions_.MergeFrom(from.descriptions_);
  lengths_.MergeFrom(from.lengths_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      prefixes_num_ = from.prefixes_num_;
    }
    if (cached_has_bits & 0x00000002u) {
      lengths_num_ = from.lengths_num_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

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

bool PrefixesInfo::IsInitialized() const {
  if (_Internal::MissingRequiredFields(_has_bits_)) return false;
  return true;
}

void PrefixesInfo::InternalSwap(PrefixesInfo* other) {
  using std::swap;
  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  prefixes_.InternalSwap(&other->prefixes_);
  descriptions_.InternalSwap(&other->descriptions_);
  lengths_.InternalSwap(&other->lengths_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(PrefixesInfo, lengths_num_)
      + sizeof(PrefixesInfo::lengths_num_)
      - PROTOBUF_FIELD_OFFSET(PrefixesInfo, prefixes_num_)>(
          reinterpret_cast<char*>(&prefixes_num_),
          reinterpret_cast<char*>(&other->prefixes_num_));
}

std::string PrefixesInfo::GetTypeName() const {
  return "i18n.phonenumbers.PrefixesInfo";
}


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

void LanguageCodeInfo::InitAsDefaultInstance() {
}
class LanguageCodeInfo::_Internal {
 public:
  using HasBits = decltype(std::declval<LanguageCodeInfo>()._has_bits_);
  static void set_has_language_codes_num(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static bool MissingRequiredFields(const HasBits& has_bits) {
    return ((has_bits[0] & 0x00000001) ^ 0x00000001) != 0;
  }
};

LanguageCodeInfo::LanguageCodeInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
  language_codes_(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:i18n.phonenumbers.LanguageCodeInfo)
}
LanguageCodeInfo::LanguageCodeInfo(const LanguageCodeInfo& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
      _has_bits_(from._has_bits_),
      language_codes_(from.language_codes_) {
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  language_codes_num_ = from.language_codes_num_;
  // @@protoc_insertion_point(copy_constructor:i18n.phonenumbers.LanguageCodeInfo)
}

void LanguageCodeInfo::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_LanguageCodeInfo_geocoding_5fdata_2eproto.base);
  language_codes_num_ = 0;
}

LanguageCodeInfo::~LanguageCodeInfo() {
  // @@protoc_insertion_point(destructor:i18n.phonenumbers.LanguageCodeInfo)
  SharedDtor();
  _internal_metadata_.Delete<std::string>();
}

void LanguageCodeInfo::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
}

void LanguageCodeInfo::ArenaDtor(void* object) {
  LanguageCodeInfo* _this = reinterpret_cast< LanguageCodeInfo* >(object);
  (void)_this;
}
void LanguageCodeInfo::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void LanguageCodeInfo::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const LanguageCodeInfo& LanguageCodeInfo::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_LanguageCodeInfo_geocoding_5fdata_2eproto.base);
  return *internal_default_instance();
}


void LanguageCodeInfo::Clear() {
// @@protoc_insertion_point(message_clear_start:i18n.phonenumbers.LanguageCodeInfo)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  language_codes_.Clear();
  language_codes_num_ = 0;
  _has_bits_.Clear();
  _internal_metadata_.Clear<std::string>();
}

const char* LanguageCodeInfo::_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) {
      // required int32 language_codes_num = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_language_codes_num(&has_bits);
          language_codes_num_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated string language_codes = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr -= 1;
          do {
            ptr += 1;
            auto str = _internal_add_language_codes();
            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(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<std::string>(),
            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* LanguageCodeInfo::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:i18n.phonenumbers.LanguageCodeInfo)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required int32 language_codes_num = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_language_codes_num(), target);
  }

  // repeated string language_codes = 2;
  for (int i = 0, n = this->_internal_language_codes_size(); i < n; i++) {
    const auto& s = this->_internal_language_codes(i);
    target = stream->WriteString(2, s, target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:i18n.phonenumbers.LanguageCodeInfo)
  return target;
}

size_t LanguageCodeInfo::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:i18n.phonenumbers.LanguageCodeInfo)
  size_t total_size = 0;

  // required int32 language_codes_num = 1;
  if (_internal_has_language_codes_num()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_language_codes_num());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated string language_codes = 2;
  total_size += 1 *
      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(language_codes_.size());
  for (int i = 0, n = language_codes_.size(); i < n; i++) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
      language_codes_.Get(i));
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void LanguageCodeInfo::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const LanguageCodeInfo*>(
      &from));
}

void LanguageCodeInfo::MergeFrom(const LanguageCodeInfo& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:i18n.phonenumbers.LanguageCodeInfo)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  language_codes_.MergeFrom(from.language_codes_);
  if (from._internal_has_language_codes_num()) {
    _internal_set_language_codes_num(from._internal_language_codes_num());
  }
}

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

bool LanguageCodeInfo::IsInitialized() const {
  if (_Internal::MissingRequiredFields(_has_bits_)) return false;
  return true;
}

void LanguageCodeInfo::InternalSwap(LanguageCodeInfo* other) {
  using std::swap;
  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  language_codes_.InternalSwap(&other->language_codes_);
  swap(language_codes_num_, other->language_codes_num_);
}

std::string LanguageCodeInfo::GetTypeName() const {
  return "i18n.phonenumbers.LanguageCodeInfo";
}


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

void CountriesInfo::InitAsDefaultInstance() {
}
class CountriesInfo::_Internal {
 public:
  using HasBits = decltype(std::declval<CountriesInfo>()._has_bits_);
  static void set_has_country_languages_num(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static bool MissingRequiredFields(const HasBits& has_bits) {
    return ((has_bits[0] & 0x00000001) ^ 0x00000001) != 0;
  }
};

CountriesInfo::CountriesInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
  country_languages_(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:i18n.phonenumbers.CountriesInfo)
}
CountriesInfo::CountriesInfo(const CountriesInfo& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
      _has_bits_(from._has_bits_),
      country_languages_(from.country_languages_) {
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  country_languages_num_ = from.country_languages_num_;
  // @@protoc_insertion_point(copy_constructor:i18n.phonenumbers.CountriesInfo)
}

void CountriesInfo::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_CountriesInfo_geocoding_5fdata_2eproto.base);
  country_languages_num_ = 0;
}

CountriesInfo::~CountriesInfo() {
  // @@protoc_insertion_point(destructor:i18n.phonenumbers.CountriesInfo)
  SharedDtor();
  _internal_metadata_.Delete<std::string>();
}

void CountriesInfo::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
}

void CountriesInfo::ArenaDtor(void* object) {
  CountriesInfo* _this = reinterpret_cast< CountriesInfo* >(object);
  (void)_this;
}
void CountriesInfo::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void CountriesInfo::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const CountriesInfo& CountriesInfo::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_CountriesInfo_geocoding_5fdata_2eproto.base);
  return *internal_default_instance();
}


void CountriesInfo::Clear() {
// @@protoc_insertion_point(message_clear_start:i18n.phonenumbers.CountriesInfo)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  country_languages_.Clear();
  country_languages_num_ = 0;
  _has_bits_.Clear();
  _internal_metadata_.Clear<std::string>();
}

const char* CountriesInfo::_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) {
      // required int32 country_languages_num = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_country_languages_num(&has_bits);
          country_languages_num_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated string country_languages = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr -= 1;
          do {
            ptr += 1;
            auto str = _internal_add_country_languages();
            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(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<std::string>(),
            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* CountriesInfo::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:i18n.phonenumbers.CountriesInfo)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required int32 country_languages_num = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_country_languages_num(), target);
  }

  // repeated string country_languages = 2;
  for (int i = 0, n = this->_internal_country_languages_size(); i < n; i++) {
    const auto& s = this->_internal_country_languages(i);
    target = stream->WriteString(2, s, target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:i18n.phonenumbers.CountriesInfo)
  return target;
}

size_t CountriesInfo::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:i18n.phonenumbers.CountriesInfo)
  size_t total_size = 0;

  // required int32 country_languages_num = 1;
  if (_internal_has_country_languages_num()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_country_languages_num());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated string country_languages = 2;
  total_size += 1 *
      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(country_languages_.size());
  for (int i = 0, n = country_languages_.size(); i < n; i++) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
      country_languages_.Get(i));
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void CountriesInfo::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const CountriesInfo*>(
      &from));
}

void CountriesInfo::MergeFrom(const CountriesInfo& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:i18n.phonenumbers.CountriesInfo)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  country_languages_.MergeFrom(from.country_languages_);
  if (from._internal_has_country_languages_num()) {
    _internal_set_country_languages_num(from._internal_country_languages_num());
  }
}

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

bool CountriesInfo::IsInitialized() const {
  if (_Internal::MissingRequiredFields(_has_bits_)) return false;
  return true;
}

void CountriesInfo::InternalSwap(CountriesInfo* other) {
  using std::swap;
  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  country_languages_.InternalSwap(&other->country_languages_);
  swap(country_languages_num_, other->country_languages_num_);
}

std::string CountriesInfo::GetTypeName() const {
  return "i18n.phonenumbers.CountriesInfo";
}


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

void CountryCodeInfo::InitAsDefaultInstance() {
}
class CountryCodeInfo::_Internal {
 public:
  using HasBits = decltype(std::declval<CountryCodeInfo>()._has_bits_);
  static void set_has_country_codes_num(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static bool MissingRequiredFields(const HasBits& has_bits) {
    return ((has_bits[0] & 0x00000001) ^ 0x00000001) != 0;
  }
};

CountryCodeInfo::CountryCodeInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
  country_codes_(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:i18n.phonenumbers.CountryCodeInfo)
}
CountryCodeInfo::CountryCodeInfo(const CountryCodeInfo& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
      _has_bits_(from._has_bits_),
      country_codes_(from.country_codes_) {
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  country_codes_num_ = from.country_codes_num_;
  // @@protoc_insertion_point(copy_constructor:i18n.phonenumbers.CountryCodeInfo)
}

void CountryCodeInfo::SharedCtor() {
  country_codes_num_ = 0;
}

CountryCodeInfo::~CountryCodeInfo() {
  // @@protoc_insertion_point(destructor:i18n.phonenumbers.CountryCodeInfo)
  SharedDtor();
  _internal_metadata_.Delete<std::string>();
}

void CountryCodeInfo::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
}

void CountryCodeInfo::ArenaDtor(void* object) {
  CountryCodeInfo* _this = reinterpret_cast< CountryCodeInfo* >(object);
  (void)_this;
}
void CountryCodeInfo::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void CountryCodeInfo::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const CountryCodeInfo& CountryCodeInfo::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_CountryCodeInfo_geocoding_5fdata_2eproto.base);
  return *internal_default_instance();
}


void CountryCodeInfo::Clear() {
// @@protoc_insertion_point(message_clear_start:i18n.phonenumbers.CountryCodeInfo)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  country_codes_.Clear();
  country_codes_num_ = 0;
  _has_bits_.Clear();
  _internal_metadata_.Clear<std::string>();
}

const char* CountryCodeInfo::_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) {
      // required int32 country_codes_num = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_country_codes_num(&has_bits);
          country_codes_num_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated int32 country_codes = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          ptr -= 1;
          do {
            ptr += 1;
            _internal_add_country_codes(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<16>(ptr));
        } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt32Parser(_internal_mutable_country_codes(), ptr, ctx);
          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<std::string>(),
            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* CountryCodeInfo::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:i18n.phonenumbers.CountryCodeInfo)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required int32 country_codes_num = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_country_codes_num(), target);
  }

  // repeated int32 country_codes = 2;
  for (int i = 0, n = this->_internal_country_codes_size(); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_country_codes(i), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:i18n.phonenumbers.CountryCodeInfo)
  return target;
}

size_t CountryCodeInfo::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:i18n.phonenumbers.CountryCodeInfo)
  size_t total_size = 0;

  // required int32 country_codes_num = 1;
  if (_internal_has_country_codes_num()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_country_codes_num());
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated int32 country_codes = 2;
  {
    size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      Int32Size(this->country_codes_);
    total_size += 1 *
                  ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_country_codes_size());
    total_size += data_size;
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void CountryCodeInfo::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::PROTOBUF_NAMESPACE_ID::internal::DownCast<const CountryCodeInfo*>(
      &from));
}

void CountryCodeInfo::MergeFrom(const CountryCodeInfo& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:i18n.phonenumbers.CountryCodeInfo)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  country_codes_.MergeFrom(from.country_codes_);
  if (from._internal_has_country_codes_num()) {
    _internal_set_country_codes_num(from._internal_country_codes_num());
  }
}

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

bool CountryCodeInfo::IsInitialized() const {
  if (_Internal::MissingRequiredFields(_has_bits_)) return false;
  return true;
}

void CountryCodeInfo::InternalSwap(CountryCodeInfo* other) {
  using std::swap;
  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  country_codes_.InternalSwap(&other->country_codes_);
  swap(country_codes_num_, other->country_codes_num_);
}

std::string CountryCodeInfo::GetTypeName() const {
  return "i18n.phonenumbers.CountryCodeInfo";
}


// @@protoc_insertion_point(namespace_scope)
}  // namespace phonenumbers
}  // namespace i18n
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::i18n::phonenumbers::GeocodingInfo* Arena::CreateMaybeMessage< ::i18n::phonenumbers::GeocodingInfo >(Arena* arena) {
  return Arena::CreateMessageInternal< ::i18n::phonenumbers::GeocodingInfo >(arena);
}
template<> PROTOBUF_NOINLINE ::i18n::phonenumbers::PrefixesInfo* Arena::CreateMaybeMessage< ::i18n::phonenumbers::PrefixesInfo >(Arena* arena) {
  return Arena::CreateMessageInternal< ::i18n::phonenumbers::PrefixesInfo >(arena);
}
template<> PROTOBUF_NOINLINE ::i18n::phonenumbers::LanguageCodeInfo* Arena::CreateMaybeMessage< ::i18n::phonenumbers::LanguageCodeInfo >(Arena* arena) {
  return Arena::CreateMessageInternal< ::i18n::phonenumbers::LanguageCodeInfo >(arena);
}
template<> PROTOBUF_NOINLINE ::i18n::phonenumbers::CountriesInfo* Arena::CreateMaybeMessage< ::i18n::phonenumbers::CountriesInfo >(Arena* arena) {
  return Arena::CreateMessageInternal< ::i18n::phonenumbers::CountriesInfo >(arena);
}
template<> PROTOBUF_NOINLINE ::i18n::phonenumbers::CountryCodeInfo* Arena::CreateMaybeMessage< ::i18n::phonenumbers::CountryCodeInfo >(Arena* arena) {
  return Arena::CreateMessageInternal< ::i18n::phonenumbers::CountryCodeInfo >(arena);
}
PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)
#include <google/protobuf/port_undef.inc>