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

#ifndef GOOGLE_PROTOBUF_INCLUDED_steamnetworkingsockets_5fmessages_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_steamnetworkingsockets_5fmessages_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3021000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers. Please update
#error your headers.
#endif
#if 3021008 < PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/metadata_lite.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
#include "steamnetworkingsockets_messages_certs.pb.h"
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_steamnetworkingsockets_5fmessages_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_steamnetworkingsockets_5fmessages_2eproto {
  static const uint32_t offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_steamnetworkingsockets_5fmessages_2eproto;
class CMsgICECandidate;
struct CMsgICECandidateDefaultTypeInternal;
extern CMsgICECandidateDefaultTypeInternal _CMsgICECandidate_default_instance_;
class CMsgICERendezvous;
struct CMsgICERendezvousDefaultTypeInternal;
extern CMsgICERendezvousDefaultTypeInternal _CMsgICERendezvous_default_instance_;
class CMsgICERendezvous_Auth;
struct CMsgICERendezvous_AuthDefaultTypeInternal;
extern CMsgICERendezvous_AuthDefaultTypeInternal _CMsgICERendezvous_Auth_default_instance_;
class CMsgSteamDatagramConnectionQuality;
struct CMsgSteamDatagramConnectionQualityDefaultTypeInternal;
extern CMsgSteamDatagramConnectionQualityDefaultTypeInternal _CMsgSteamDatagramConnectionQuality_default_instance_;
class CMsgSteamDatagramDiagnostic;
struct CMsgSteamDatagramDiagnosticDefaultTypeInternal;
extern CMsgSteamDatagramDiagnosticDefaultTypeInternal _CMsgSteamDatagramDiagnostic_default_instance_;
class CMsgSteamDatagramLinkInstantaneousStats;
struct CMsgSteamDatagramLinkInstantaneousStatsDefaultTypeInternal;
extern CMsgSteamDatagramLinkInstantaneousStatsDefaultTypeInternal _CMsgSteamDatagramLinkInstantaneousStats_default_instance_;
class CMsgSteamDatagramLinkLifetimeStats;
struct CMsgSteamDatagramLinkLifetimeStatsDefaultTypeInternal;
extern CMsgSteamDatagramLinkLifetimeStatsDefaultTypeInternal _CMsgSteamDatagramLinkLifetimeStats_default_instance_;
class CMsgSteamDatagramSessionCryptInfo;
struct CMsgSteamDatagramSessionCryptInfoDefaultTypeInternal;
extern CMsgSteamDatagramSessionCryptInfoDefaultTypeInternal _CMsgSteamDatagramSessionCryptInfo_default_instance_;
class CMsgSteamDatagramSessionCryptInfoSigned;
struct CMsgSteamDatagramSessionCryptInfoSignedDefaultTypeInternal;
extern CMsgSteamDatagramSessionCryptInfoSignedDefaultTypeInternal _CMsgSteamDatagramSessionCryptInfoSigned_default_instance_;
class CMsgSteamNetworkingICESessionSummary;
struct CMsgSteamNetworkingICESessionSummaryDefaultTypeInternal;
extern CMsgSteamNetworkingICESessionSummaryDefaultTypeInternal _CMsgSteamNetworkingICESessionSummary_default_instance_;
class CMsgSteamNetworkingP2PRendezvous;
struct CMsgSteamNetworkingP2PRendezvousDefaultTypeInternal;
extern CMsgSteamNetworkingP2PRendezvousDefaultTypeInternal _CMsgSteamNetworkingP2PRendezvous_default_instance_;
class CMsgSteamNetworkingP2PRendezvous_ApplicationMessage;
struct CMsgSteamNetworkingP2PRendezvous_ApplicationMessageDefaultTypeInternal;
extern CMsgSteamNetworkingP2PRendezvous_ApplicationMessageDefaultTypeInternal _CMsgSteamNetworkingP2PRendezvous_ApplicationMessage_default_instance_;
class CMsgSteamNetworkingP2PRendezvous_ConnectOK;
struct CMsgSteamNetworkingP2PRendezvous_ConnectOKDefaultTypeInternal;
extern CMsgSteamNetworkingP2PRendezvous_ConnectOKDefaultTypeInternal _CMsgSteamNetworkingP2PRendezvous_ConnectOK_default_instance_;
class CMsgSteamNetworkingP2PRendezvous_ConnectRequest;
struct CMsgSteamNetworkingP2PRendezvous_ConnectRequestDefaultTypeInternal;
extern CMsgSteamNetworkingP2PRendezvous_ConnectRequestDefaultTypeInternal _CMsgSteamNetworkingP2PRendezvous_ConnectRequest_default_instance_;
class CMsgSteamNetworkingP2PRendezvous_ConnectionClosed;
struct CMsgSteamNetworkingP2PRendezvous_ConnectionClosedDefaultTypeInternal;
extern CMsgSteamNetworkingP2PRendezvous_ConnectionClosedDefaultTypeInternal _CMsgSteamNetworkingP2PRendezvous_ConnectionClosed_default_instance_;
class CMsgSteamNetworkingP2PRendezvous_ReliableMessage;
struct CMsgSteamNetworkingP2PRendezvous_ReliableMessageDefaultTypeInternal;
extern CMsgSteamNetworkingP2PRendezvous_ReliableMessageDefaultTypeInternal _CMsgSteamNetworkingP2PRendezvous_ReliableMessage_default_instance_;
PROTOBUF_NAMESPACE_OPEN
template<> ::CMsgICECandidate* Arena::CreateMaybeMessage<::CMsgICECandidate>(Arena*);
template<> ::CMsgICERendezvous* Arena::CreateMaybeMessage<::CMsgICERendezvous>(Arena*);
template<> ::CMsgICERendezvous_Auth* Arena::CreateMaybeMessage<::CMsgICERendezvous_Auth>(Arena*);
template<> ::CMsgSteamDatagramConnectionQuality* Arena::CreateMaybeMessage<::CMsgSteamDatagramConnectionQuality>(Arena*);
template<> ::CMsgSteamDatagramDiagnostic* Arena::CreateMaybeMessage<::CMsgSteamDatagramDiagnostic>(Arena*);
template<> ::CMsgSteamDatagramLinkInstantaneousStats* Arena::CreateMaybeMessage<::CMsgSteamDatagramLinkInstantaneousStats>(Arena*);
template<> ::CMsgSteamDatagramLinkLifetimeStats* Arena::CreateMaybeMessage<::CMsgSteamDatagramLinkLifetimeStats>(Arena*);
template<> ::CMsgSteamDatagramSessionCryptInfo* Arena::CreateMaybeMessage<::CMsgSteamDatagramSessionCryptInfo>(Arena*);
template<> ::CMsgSteamDatagramSessionCryptInfoSigned* Arena::CreateMaybeMessage<::CMsgSteamDatagramSessionCryptInfoSigned>(Arena*);
template<> ::CMsgSteamNetworkingICESessionSummary* Arena::CreateMaybeMessage<::CMsgSteamNetworkingICESessionSummary>(Arena*);
template<> ::CMsgSteamNetworkingP2PRendezvous* Arena::CreateMaybeMessage<::CMsgSteamNetworkingP2PRendezvous>(Arena*);
template<> ::CMsgSteamNetworkingP2PRendezvous_ApplicationMessage* Arena::CreateMaybeMessage<::CMsgSteamNetworkingP2PRendezvous_ApplicationMessage>(Arena*);
template<> ::CMsgSteamNetworkingP2PRendezvous_ConnectOK* Arena::CreateMaybeMessage<::CMsgSteamNetworkingP2PRendezvous_ConnectOK>(Arena*);
template<> ::CMsgSteamNetworkingP2PRendezvous_ConnectRequest* Arena::CreateMaybeMessage<::CMsgSteamNetworkingP2PRendezvous_ConnectRequest>(Arena*);
template<> ::CMsgSteamNetworkingP2PRendezvous_ConnectionClosed* Arena::CreateMaybeMessage<::CMsgSteamNetworkingP2PRendezvous_ConnectionClosed>(Arena*);
template<> ::CMsgSteamNetworkingP2PRendezvous_ReliableMessage* Arena::CreateMaybeMessage<::CMsgSteamNetworkingP2PRendezvous_ReliableMessage>(Arena*);
PROTOBUF_NAMESPACE_CLOSE

enum CMsgSteamDatagramSessionCryptInfo_EKeyType : int {
  CMsgSteamDatagramSessionCryptInfo_EKeyType_INVALID = 0,
  CMsgSteamDatagramSessionCryptInfo_EKeyType_CURVE25519 = 1
};
bool CMsgSteamDatagramSessionCryptInfo_EKeyType_IsValid(int value);
constexpr CMsgSteamDatagramSessionCryptInfo_EKeyType CMsgSteamDatagramSessionCryptInfo_EKeyType_EKeyType_MIN = CMsgSteamDatagramSessionCryptInfo_EKeyType_INVALID;
constexpr CMsgSteamDatagramSessionCryptInfo_EKeyType CMsgSteamDatagramSessionCryptInfo_EKeyType_EKeyType_MAX = CMsgSteamDatagramSessionCryptInfo_EKeyType_CURVE25519;
constexpr int CMsgSteamDatagramSessionCryptInfo_EKeyType_EKeyType_ARRAYSIZE = CMsgSteamDatagramSessionCryptInfo_EKeyType_EKeyType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* CMsgSteamDatagramSessionCryptInfo_EKeyType_descriptor();
template<typename T>
inline const std::string& CMsgSteamDatagramSessionCryptInfo_EKeyType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, CMsgSteamDatagramSessionCryptInfo_EKeyType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function CMsgSteamDatagramSessionCryptInfo_EKeyType_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    CMsgSteamDatagramSessionCryptInfo_EKeyType_descriptor(), enum_t_value);
}
inline bool CMsgSteamDatagramSessionCryptInfo_EKeyType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, CMsgSteamDatagramSessionCryptInfo_EKeyType* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<CMsgSteamDatagramSessionCryptInfo_EKeyType>(
    CMsgSteamDatagramSessionCryptInfo_EKeyType_descriptor(), name, value);
}
enum ESteamNetworkingSocketsCipher : int {
  k_ESteamNetworkingSocketsCipher_INVALID = 0,
  k_ESteamNetworkingSocketsCipher_NULL = 1,
  k_ESteamNetworkingSocketsCipher_AES_256_GCM = 2
};
bool ESteamNetworkingSocketsCipher_IsValid(int value);
constexpr ESteamNetworkingSocketsCipher ESteamNetworkingSocketsCipher_MIN = k_ESteamNetworkingSocketsCipher_INVALID;
constexpr ESteamNetworkingSocketsCipher ESteamNetworkingSocketsCipher_MAX = k_ESteamNetworkingSocketsCipher_AES_256_GCM;
constexpr int ESteamNetworkingSocketsCipher_ARRAYSIZE = ESteamNetworkingSocketsCipher_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ESteamNetworkingSocketsCipher_descriptor();
template<typename T>
inline const std::string& ESteamNetworkingSocketsCipher_Name(T enum_t_value) {
  static_assert(::std::is_same<T, ESteamNetworkingSocketsCipher>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function ESteamNetworkingSocketsCipher_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    ESteamNetworkingSocketsCipher_descriptor(), enum_t_value);
}
inline bool ESteamNetworkingSocketsCipher_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ESteamNetworkingSocketsCipher* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ESteamNetworkingSocketsCipher>(
    ESteamNetworkingSocketsCipher_descriptor(), name, value);
}
// ===================================================================

class CMsgSteamDatagramSessionCryptInfo final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CMsgSteamDatagramSessionCryptInfo) */ {
 public:
  inline CMsgSteamDatagramSessionCryptInfo() : CMsgSteamDatagramSessionCryptInfo(nullptr) {}
  ~CMsgSteamDatagramSessionCryptInfo() override;
  explicit PROTOBUF_CONSTEXPR CMsgSteamDatagramSessionCryptInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgSteamDatagramSessionCryptInfo(const CMsgSteamDatagramSessionCryptInfo& from);
  CMsgSteamDatagramSessionCryptInfo(CMsgSteamDatagramSessionCryptInfo&& from) noexcept
    : CMsgSteamDatagramSessionCryptInfo() {
    *this = ::std::move(from);
  }

  inline CMsgSteamDatagramSessionCryptInfo& operator=(const CMsgSteamDatagramSessionCryptInfo& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgSteamDatagramSessionCryptInfo& operator=(CMsgSteamDatagramSessionCryptInfo&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgSteamDatagramSessionCryptInfo& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgSteamDatagramSessionCryptInfo* internal_default_instance() {
    return reinterpret_cast<const CMsgSteamDatagramSessionCryptInfo*>(
               &_CMsgSteamDatagramSessionCryptInfo_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  friend void swap(CMsgSteamDatagramSessionCryptInfo& a, CMsgSteamDatagramSessionCryptInfo& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgSteamDatagramSessionCryptInfo* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgSteamDatagramSessionCryptInfo* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgSteamDatagramSessionCryptInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgSteamDatagramSessionCryptInfo>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgSteamDatagramSessionCryptInfo& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgSteamDatagramSessionCryptInfo& from) {
    CMsgSteamDatagramSessionCryptInfo::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CMsgSteamDatagramSessionCryptInfo* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgSteamDatagramSessionCryptInfo";
  }
  protected:
  explicit CMsgSteamDatagramSessionCryptInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef CMsgSteamDatagramSessionCryptInfo_EKeyType EKeyType;
  static constexpr EKeyType INVALID =
    CMsgSteamDatagramSessionCryptInfo_EKeyType_INVALID;
  static constexpr EKeyType CURVE25519 =
    CMsgSteamDatagramSessionCryptInfo_EKeyType_CURVE25519;
  static inline bool EKeyType_IsValid(int value) {
    return CMsgSteamDatagramSessionCryptInfo_EKeyType_IsValid(value);
  }
  static constexpr EKeyType EKeyType_MIN =
    CMsgSteamDatagramSessionCryptInfo_EKeyType_EKeyType_MIN;
  static constexpr EKeyType EKeyType_MAX =
    CMsgSteamDatagramSessionCryptInfo_EKeyType_EKeyType_MAX;
  static constexpr int EKeyType_ARRAYSIZE =
    CMsgSteamDatagramSessionCryptInfo_EKeyType_EKeyType_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  EKeyType_descriptor() {
    return CMsgSteamDatagramSessionCryptInfo_EKeyType_descriptor();
  }
  template<typename T>
  static inline const std::string& EKeyType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, EKeyType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function EKeyType_Name.");
    return CMsgSteamDatagramSessionCryptInfo_EKeyType_Name(enum_t_value);
  }
  static inline bool EKeyType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      EKeyType* value) {
    return CMsgSteamDatagramSessionCryptInfo_EKeyType_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  enum : int {
    kCiphersFieldNumber = 5,
    kKeyDataFieldNumber = 2,
    kKeyTypeFieldNumber = 1,
    kProtocolVersionFieldNumber = 4,
    kNonceFieldNumber = 3,
  };
  // repeated .ESteamNetworkingSocketsCipher ciphers = 5;
  int ciphers_size() const;
  private:
  int _internal_ciphers_size() const;
  public:
  void clear_ciphers();
  private:
  ::ESteamNetworkingSocketsCipher _internal_ciphers(int index) const;
  void _internal_add_ciphers(::ESteamNetworkingSocketsCipher value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* _internal_mutable_ciphers();
  public:
  ::ESteamNetworkingSocketsCipher ciphers(int index) const;
  void set_ciphers(int index, ::ESteamNetworkingSocketsCipher value);
  void add_ciphers(::ESteamNetworkingSocketsCipher value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>& ciphers() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* mutable_ciphers();

  // optional bytes key_data = 2;
  bool has_key_data() const;
  private:
  bool _internal_has_key_data() const;
  public:
  void clear_key_data();
  const std::string& key_data() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_key_data(ArgT0&& arg0, ArgT... args);
  std::string* mutable_key_data();
  PROTOBUF_NODISCARD std::string* release_key_data();
  void set_allocated_key_data(std::string* key_data);
  private:
  const std::string& _internal_key_data() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_key_data(const std::string& value);
  std::string* _internal_mutable_key_data();
  public:

  // optional .CMsgSteamDatagramSessionCryptInfo.EKeyType key_type = 1 [default = INVALID];
  bool has_key_type() const;
  private:
  bool _internal_has_key_type() const;
  public:
  void clear_key_type();
  ::CMsgSteamDatagramSessionCryptInfo_EKeyType key_type() const;
  void set_key_type(::CMsgSteamDatagramSessionCryptInfo_EKeyType value);
  private:
  ::CMsgSteamDatagramSessionCryptInfo_EKeyType _internal_key_type() const;
  void _internal_set_key_type(::CMsgSteamDatagramSessionCryptInfo_EKeyType value);
  public:

  // optional uint32 protocol_version = 4;
  bool has_protocol_version() const;
  private:
  bool _internal_has_protocol_version() const;
  public:
  void clear_protocol_version();
  uint32_t protocol_version() const;
  void set_protocol_version(uint32_t value);
  private:
  uint32_t _internal_protocol_version() const;
  void _internal_set_protocol_version(uint32_t value);
  public:

  // optional fixed64 nonce = 3;
  bool has_nonce() const;
  private:
  bool _internal_has_nonce() const;
  public:
  void clear_nonce();
  uint64_t nonce() const;
  void set_nonce(uint64_t value);
  private:
  uint64_t _internal_nonce() const;
  void _internal_set_nonce(uint64_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgSteamDatagramSessionCryptInfo)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField<int> ciphers_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_data_;
    int key_type_;
    uint32_t protocol_version_;
    uint64_t nonce_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_steamnetworkingsockets_5fmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgSteamDatagramSessionCryptInfoSigned final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CMsgSteamDatagramSessionCryptInfoSigned) */ {
 public:
  inline CMsgSteamDatagramSessionCryptInfoSigned() : CMsgSteamDatagramSessionCryptInfoSigned(nullptr) {}
  ~CMsgSteamDatagramSessionCryptInfoSigned() override;
  explicit PROTOBUF_CONSTEXPR CMsgSteamDatagramSessionCryptInfoSigned(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgSteamDatagramSessionCryptInfoSigned(const CMsgSteamDatagramSessionCryptInfoSigned& from);
  CMsgSteamDatagramSessionCryptInfoSigned(CMsgSteamDatagramSessionCryptInfoSigned&& from) noexcept
    : CMsgSteamDatagramSessionCryptInfoSigned() {
    *this = ::std::move(from);
  }

  inline CMsgSteamDatagramSessionCryptInfoSigned& operator=(const CMsgSteamDatagramSessionCryptInfoSigned& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgSteamDatagramSessionCryptInfoSigned& operator=(CMsgSteamDatagramSessionCryptInfoSigned&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgSteamDatagramSessionCryptInfoSigned& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgSteamDatagramSessionCryptInfoSigned* internal_default_instance() {
    return reinterpret_cast<const CMsgSteamDatagramSessionCryptInfoSigned*>(
               &_CMsgSteamDatagramSessionCryptInfoSigned_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

  friend void swap(CMsgSteamDatagramSessionCryptInfoSigned& a, CMsgSteamDatagramSessionCryptInfoSigned& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgSteamDatagramSessionCryptInfoSigned* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgSteamDatagramSessionCryptInfoSigned* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgSteamDatagramSessionCryptInfoSigned* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgSteamDatagramSessionCryptInfoSigned>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgSteamDatagramSessionCryptInfoSigned& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgSteamDatagramSessionCryptInfoSigned& from) {
    CMsgSteamDatagramSessionCryptInfoSigned::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CMsgSteamDatagramSessionCryptInfoSigned* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgSteamDatagramSessionCryptInfoSigned";
  }
  protected:
  explicit CMsgSteamDatagramSessionCryptInfoSigned(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kInfoFieldNumber = 1,
    kSignatureFieldNumber = 2,
  };
  // optional bytes info = 1;
  bool has_info() const;
  private:
  bool _internal_has_info() const;
  public:
  void clear_info();
  const std::string& info() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_info(ArgT0&& arg0, ArgT... args);
  std::string* mutable_info();
  PROTOBUF_NODISCARD std::string* release_info();
  void set_allocated_info(std::string* info);
  private:
  const std::string& _internal_info() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_info(const std::string& value);
  std::string* _internal_mutable_info();
  public:

  // optional bytes signature = 2;
  bool has_signature() const;
  private:
  bool _internal_has_signature() const;
  public:
  void clear_signature();
  const std::string& signature() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_signature(ArgT0&& arg0, ArgT... args);
  std::string* mutable_signature();
  PROTOBUF_NODISCARD std::string* release_signature();
  void set_allocated_signature(std::string* signature);
  private:
  const std::string& _internal_signature() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_signature(const std::string& value);
  std::string* _internal_mutable_signature();
  public:

  // @@protoc_insertion_point(class_scope:CMsgSteamDatagramSessionCryptInfoSigned)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr info_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr signature_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_steamnetworkingsockets_5fmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgSteamDatagramDiagnostic final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CMsgSteamDatagramDiagnostic) */ {
 public:
  inline CMsgSteamDatagramDiagnostic() : CMsgSteamDatagramDiagnostic(nullptr) {}
  ~CMsgSteamDatagramDiagnostic() override;
  explicit PROTOBUF_CONSTEXPR CMsgSteamDatagramDiagnostic(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgSteamDatagramDiagnostic(const CMsgSteamDatagramDiagnostic& from);
  CMsgSteamDatagramDiagnostic(CMsgSteamDatagramDiagnostic&& from) noexcept
    : CMsgSteamDatagramDiagnostic() {
    *this = ::std::move(from);
  }

  inline CMsgSteamDatagramDiagnostic& operator=(const CMsgSteamDatagramDiagnostic& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgSteamDatagramDiagnostic& operator=(CMsgSteamDatagramDiagnostic&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgSteamDatagramDiagnostic& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgSteamDatagramDiagnostic* internal_default_instance() {
    return reinterpret_cast<const CMsgSteamDatagramDiagnostic*>(
               &_CMsgSteamDatagramDiagnostic_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

  friend void swap(CMsgSteamDatagramDiagnostic& a, CMsgSteamDatagramDiagnostic& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgSteamDatagramDiagnostic* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgSteamDatagramDiagnostic* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgSteamDatagramDiagnostic* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgSteamDatagramDiagnostic>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgSteamDatagramDiagnostic& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgSteamDatagramDiagnostic& from) {
    CMsgSteamDatagramDiagnostic::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CMsgSteamDatagramDiagnostic* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgSteamDatagramDiagnostic";
  }
  protected:
  explicit CMsgSteamDatagramDiagnostic(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kTextFieldNumber = 2,
    kSeverityFieldNumber = 1,
  };
  // optional string text = 2;
  bool has_text() const;
  private:
  bool _internal_has_text() const;
  public:
  void clear_text();
  const std::string& text() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_text(ArgT0&& arg0, ArgT... args);
  std::string* mutable_text();
  PROTOBUF_NODISCARD std::string* release_text();
  void set_allocated_text(std::string* text);
  private:
  const std::string& _internal_text() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_text(const std::string& value);
  std::string* _internal_mutable_text();
  public:

  // optional uint32 severity = 1;
  bool has_severity() const;
  private:
  bool _internal_has_severity() const;
  public:
  void clear_severity();
  uint32_t severity() const;
  void set_severity(uint32_t value);
  private:
  uint32_t _internal_severity() const;
  void _internal_set_severity(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgSteamDatagramDiagnostic)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr text_;
    uint32_t severity_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_steamnetworkingsockets_5fmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgSteamDatagramLinkInstantaneousStats final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CMsgSteamDatagramLinkInstantaneousStats) */ {
 public:
  inline CMsgSteamDatagramLinkInstantaneousStats() : CMsgSteamDatagramLinkInstantaneousStats(nullptr) {}
  ~CMsgSteamDatagramLinkInstantaneousStats() override;
  explicit PROTOBUF_CONSTEXPR CMsgSteamDatagramLinkInstantaneousStats(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgSteamDatagramLinkInstantaneousStats(const CMsgSteamDatagramLinkInstantaneousStats& from);
  CMsgSteamDatagramLinkInstantaneousStats(CMsgSteamDatagramLinkInstantaneousStats&& from) noexcept
    : CMsgSteamDatagramLinkInstantaneousStats() {
    *this = ::std::move(from);
  }

  inline CMsgSteamDatagramLinkInstantaneousStats& operator=(const CMsgSteamDatagramLinkInstantaneousStats& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgSteamDatagramLinkInstantaneousStats& operator=(CMsgSteamDatagramLinkInstantaneousStats&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgSteamDatagramLinkInstantaneousStats& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgSteamDatagramLinkInstantaneousStats* internal_default_instance() {
    return reinterpret_cast<const CMsgSteamDatagramLinkInstantaneousStats*>(
               &_CMsgSteamDatagramLinkInstantaneousStats_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

  friend void swap(CMsgSteamDatagramLinkInstantaneousStats& a, CMsgSteamDatagramLinkInstantaneousStats& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgSteamDatagramLinkInstantaneousStats* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgSteamDatagramLinkInstantaneousStats* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgSteamDatagramLinkInstantaneousStats* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgSteamDatagramLinkInstantaneousStats>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgSteamDatagramLinkInstantaneousStats& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgSteamDatagramLinkInstantaneousStats& from) {
    CMsgSteamDatagramLinkInstantaneousStats::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CMsgSteamDatagramLinkInstantaneousStats* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgSteamDatagramLinkInstantaneousStats";
  }
  protected:
  explicit CMsgSteamDatagramLinkInstantaneousStats(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kOutPacketsPerSecX10FieldNumber = 1,
    kOutBytesPerSecFieldNumber = 2,
    kInPacketsPerSecX10FieldNumber = 3,
    kInBytesPerSecFieldNumber = 4,
    kPingMsFieldNumber = 5,
    kPacketsDroppedPctFieldNumber = 6,
    kPacketsWeirdSequencePctFieldNumber = 7,
    kPeakJitterUsecFieldNumber = 8,
  };
  // optional uint32 out_packets_per_sec_x10 = 1;
  bool has_out_packets_per_sec_x10() const;
  private:
  bool _internal_has_out_packets_per_sec_x10() const;
  public:
  void clear_out_packets_per_sec_x10();
  uint32_t out_packets_per_sec_x10() const;
  void set_out_packets_per_sec_x10(uint32_t value);
  private:
  uint32_t _internal_out_packets_per_sec_x10() const;
  void _internal_set_out_packets_per_sec_x10(uint32_t value);
  public:

  // optional uint32 out_bytes_per_sec = 2;
  bool has_out_bytes_per_sec() const;
  private:
  bool _internal_has_out_bytes_per_sec() const;
  public:
  void clear_out_bytes_per_sec();
  uint32_t out_bytes_per_sec() const;
  void set_out_bytes_per_sec(uint32_t value);
  private:
  uint32_t _internal_out_bytes_per_sec() const;
  void _internal_set_out_bytes_per_sec(uint32_t value);
  public:

  // optional uint32 in_packets_per_sec_x10 = 3;
  bool has_in_packets_per_sec_x10() const;
  private:
  bool _internal_has_in_packets_per_sec_x10() const;
  public:
  void clear_in_packets_per_sec_x10();
  uint32_t in_packets_per_sec_x10() const;
  void set_in_packets_per_sec_x10(uint32_t value);
  private:
  uint32_t _internal_in_packets_per_sec_x10() const;
  void _internal_set_in_packets_per_sec_x10(uint32_t value);
  public:

  // optional uint32 in_bytes_per_sec = 4;
  bool has_in_bytes_per_sec() const;
  private:
  bool _internal_has_in_bytes_per_sec() const;
  public:
  void clear_in_bytes_per_sec();
  uint32_t in_bytes_per_sec() const;
  void set_in_bytes_per_sec(uint32_t value);
  private:
  uint32_t _internal_in_bytes_per_sec() const;
  void _internal_set_in_bytes_per_sec(uint32_t value);
  public:

  // optional uint32 ping_ms = 5;
  bool has_ping_ms() const;
  private:
  bool _internal_has_ping_ms() const;
  public:
  void clear_ping_ms();
  uint32_t ping_ms() const;
  void set_ping_ms(uint32_t value);
  private:
  uint32_t _internal_ping_ms() const;
  void _internal_set_ping_ms(uint32_t value);
  public:

  // optional uint32 packets_dropped_pct = 6;
  bool has_packets_dropped_pct() const;
  private:
  bool _internal_has_packets_dropped_pct() const;
  public:
  void clear_packets_dropped_pct();
  uint32_t packets_dropped_pct() const;
  void set_packets_dropped_pct(uint32_t value);
  private:
  uint32_t _internal_packets_dropped_pct() const;
  void _internal_set_packets_dropped_pct(uint32_t value);
  public:

  // optional uint32 packets_weird_sequence_pct = 7;
  bool has_packets_weird_sequence_pct() const;
  private:
  bool _internal_has_packets_weird_sequence_pct() const;
  public:
  void clear_packets_weird_sequence_pct();
  uint32_t packets_weird_sequence_pct() const;
  void set_packets_weird_sequence_pct(uint32_t value);
  private:
  uint32_t _internal_packets_weird_sequence_pct() const;
  void _internal_set_packets_weird_sequence_pct(uint32_t value);
  public:

  // optional uint32 peak_jitter_usec = 8;
  bool has_peak_jitter_usec() const;
  private:
  bool _internal_has_peak_jitter_usec() const;
  public:
  void clear_peak_jitter_usec();
  uint32_t peak_jitter_usec() const;
  void set_peak_jitter_usec(uint32_t value);
  private:
  uint32_t _internal_peak_jitter_usec() const;
  void _internal_set_peak_jitter_usec(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgSteamDatagramLinkInstantaneousStats)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint32_t out_packets_per_sec_x10_;
    uint32_t out_bytes_per_sec_;
    uint32_t in_packets_per_sec_x10_;
    uint32_t in_bytes_per_sec_;
    uint32_t ping_ms_;
    uint32_t packets_dropped_pct_;
    uint32_t packets_weird_sequence_pct_;
    uint32_t peak_jitter_usec_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_steamnetworkingsockets_5fmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgSteamDatagramLinkLifetimeStats final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CMsgSteamDatagramLinkLifetimeStats) */ {
 public:
  inline CMsgSteamDatagramLinkLifetimeStats() : CMsgSteamDatagramLinkLifetimeStats(nullptr) {}
  ~CMsgSteamDatagramLinkLifetimeStats() override;
  explicit PROTOBUF_CONSTEXPR CMsgSteamDatagramLinkLifetimeStats(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgSteamDatagramLinkLifetimeStats(const CMsgSteamDatagramLinkLifetimeStats& from);
  CMsgSteamDatagramLinkLifetimeStats(CMsgSteamDatagramLinkLifetimeStats&& from) noexcept
    : CMsgSteamDatagramLinkLifetimeStats() {
    *this = ::std::move(from);
  }

  inline CMsgSteamDatagramLinkLifetimeStats& operator=(const CMsgSteamDatagramLinkLifetimeStats& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgSteamDatagramLinkLifetimeStats& operator=(CMsgSteamDatagramLinkLifetimeStats&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgSteamDatagramLinkLifetimeStats& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgSteamDatagramLinkLifetimeStats* internal_default_instance() {
    return reinterpret_cast<const CMsgSteamDatagramLinkLifetimeStats*>(
               &_CMsgSteamDatagramLinkLifetimeStats_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

  friend void swap(CMsgSteamDatagramLinkLifetimeStats& a, CMsgSteamDatagramLinkLifetimeStats& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgSteamDatagramLinkLifetimeStats* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgSteamDatagramLinkLifetimeStats* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgSteamDatagramLinkLifetimeStats* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgSteamDatagramLinkLifetimeStats>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgSteamDatagramLinkLifetimeStats& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgSteamDatagramLinkLifetimeStats& from) {
    CMsgSteamDatagramLinkLifetimeStats::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CMsgSteamDatagramLinkLifetimeStats* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgSteamDatagramLinkLifetimeStats";
  }
  protected:
  explicit CMsgSteamDatagramLinkLifetimeStats(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kMultipathPacketsRecvSequencedFieldNumber = 12,
    kMultipathPacketsRecvLaterFieldNumber = 13,
    kPacketsSentFieldNumber = 3,
    kKbSentFieldNumber = 4,
    kPacketsRecvFieldNumber = 5,
    kKbRecvFieldNumber = 6,
    kPacketsRecvSequencedFieldNumber = 7,
    kPacketsRecvDroppedFieldNumber = 8,
    kConnectedSecondsFieldNumber = 2,
    kMultipathSendEnabledFieldNumber = 14,
    kPacketsRecvOutOfOrderFieldNumber = 9,
    kPacketsRecvDuplicateFieldNumber = 10,
    kPacketsRecvLurchFieldNumber = 11,
    kPacketsRecvOutOfOrderCorrectedFieldNumber = 15,
    kQualityHistogram100FieldNumber = 21,
    kQualityHistogram99FieldNumber = 22,
    kQualityHistogram97FieldNumber = 23,
    kQualityHistogram95FieldNumber = 24,
    kQualityHistogram90FieldNumber = 25,
    kQualityHistogram75FieldNumber = 26,
    kQualityHistogram50FieldNumber = 27,
    kQualityHistogram1FieldNumber = 28,
    kQualityHistogramDeadFieldNumber = 29,
    kQualityNtile2NdFieldNumber = 30,
    kQualityNtile5ThFieldNumber = 31,
    kQualityNtile25ThFieldNumber = 32,
    kQualityNtile50ThFieldNumber = 33,
    kPingHistogram25FieldNumber = 41,
    kPingHistogram50FieldNumber = 42,
    kPingHistogram75FieldNumber = 43,
    kPingHistogram100FieldNumber = 44,
    kPingHistogram125FieldNumber = 45,
    kPingHistogram150FieldNumber = 46,
    kPingHistogram200FieldNumber = 47,
    kPingHistogram300FieldNumber = 48,
    kPingHistogramMaxFieldNumber = 49,
    kPingNtile5ThFieldNumber = 50,
    kPingNtile50ThFieldNumber = 51,
    kPingNtile75ThFieldNumber = 52,
    kPingNtile95ThFieldNumber = 53,
    kPingNtile98ThFieldNumber = 54,
    kJitterHistogramNegligibleFieldNumber = 61,
    kJitterHistogram1FieldNumber = 62,
    kJitterHistogram2FieldNumber = 63,
    kJitterHistogram5FieldNumber = 64,
    kJitterHistogram10FieldNumber = 65,
    kJitterHistogram20FieldNumber = 66,
  };
  // repeated uint64 multipath_packets_recv_sequenced = 12;
  int multipath_packets_recv_sequenced_size() const;
  private:
  int _internal_multipath_packets_recv_sequenced_size() const;
  public:
  void clear_multipath_packets_recv_sequenced();
  private:
  uint64_t _internal_multipath_packets_recv_sequenced(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
      _internal_multipath_packets_recv_sequenced() const;
  void _internal_add_multipath_packets_recv_sequenced(uint64_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
      _internal_mutable_multipath_packets_recv_sequenced();
  public:
  uint64_t multipath_packets_recv_sequenced(int index) const;
  void set_multipath_packets_recv_sequenced(int index, uint64_t value);
  void add_multipath_packets_recv_sequenced(uint64_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
      multipath_packets_recv_sequenced() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
      mutable_multipath_packets_recv_sequenced();

  // repeated uint64 multipath_packets_recv_later = 13;
  int multipath_packets_recv_later_size() const;
  private:
  int _internal_multipath_packets_recv_later_size() const;
  public:
  void clear_multipath_packets_recv_later();
  private:
  uint64_t _internal_multipath_packets_recv_later(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
      _internal_multipath_packets_recv_later() const;
  void _internal_add_multipath_packets_recv_later(uint64_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
      _internal_mutable_multipath_packets_recv_later();
  public:
  uint64_t multipath_packets_recv_later(int index) const;
  void set_multipath_packets_recv_later(int index, uint64_t value);
  void add_multipath_packets_recv_later(uint64_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
      multipath_packets_recv_later() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
      mutable_multipath_packets_recv_later();

  // optional uint64 packets_sent = 3;
  bool has_packets_sent() const;
  private:
  bool _internal_has_packets_sent() const;
  public:
  void clear_packets_sent();
  uint64_t packets_sent() const;
  void set_packets_sent(uint64_t value);
  private:
  uint64_t _internal_packets_sent() const;
  void _internal_set_packets_sent(uint64_t value);
  public:

  // optional uint64 kb_sent = 4;
  bool has_kb_sent() const;
  private:
  bool _internal_has_kb_sent() const;
  public:
  void clear_kb_sent();
  uint64_t kb_sent() const;
  void set_kb_sent(uint64_t value);
  private:
  uint64_t _internal_kb_sent() const;
  void _internal_set_kb_sent(uint64_t value);
  public:

  // optional uint64 packets_recv = 5;
  bool has_packets_recv() const;
  private:
  bool _internal_has_packets_recv() const;
  public:
  void clear_packets_recv();
  uint64_t packets_recv() const;
  void set_packets_recv(uint64_t value);
  private:
  uint64_t _internal_packets_recv() const;
  void _internal_set_packets_recv(uint64_t value);
  public:

  // optional uint64 kb_recv = 6;
  bool has_kb_recv() const;
  private:
  bool _internal_has_kb_recv() const;
  public:
  void clear_kb_recv();
  uint64_t kb_recv() const;
  void set_kb_recv(uint64_t value);
  private:
  uint64_t _internal_kb_recv() const;
  void _internal_set_kb_recv(uint64_t value);
  public:

  // optional uint64 packets_recv_sequenced = 7;
  bool has_packets_recv_sequenced() const;
  private:
  bool _internal_has_packets_recv_sequenced() const;
  public:
  void clear_packets_recv_sequenced();
  uint64_t packets_recv_sequenced() const;
  void set_packets_recv_sequenced(uint64_t value);
  private:
  uint64_t _internal_packets_recv_sequenced() const;
  void _internal_set_packets_recv_sequenced(uint64_t value);
  public:

  // optional uint64 packets_recv_dropped = 8;
  bool has_packets_recv_dropped() const;
  private:
  bool _internal_has_packets_recv_dropped() const;
  public:
  void clear_packets_recv_dropped();
  uint64_t packets_recv_dropped() const;
  void set_packets_recv_dropped(uint64_t value);
  private:
  uint64_t _internal_packets_recv_dropped() const;
  void _internal_set_packets_recv_dropped(uint64_t value);
  public:

  // optional uint32 connected_seconds = 2;
  bool has_connected_seconds() const;
  private:
  bool _internal_has_connected_seconds() const;
  public:
  void clear_connected_seconds();
  uint32_t connected_seconds() const;
  void set_connected_seconds(uint32_t value);
  private:
  uint32_t _internal_connected_seconds() const;
  void _internal_set_connected_seconds(uint32_t value);
  public:

  // optional uint32 multipath_send_enabled = 14;
  bool has_multipath_send_enabled() const;
  private:
  bool _internal_has_multipath_send_enabled() const;
  public:
  void clear_multipath_send_enabled();
  uint32_t multipath_send_enabled() const;
  void set_multipath_send_enabled(uint32_t value);
  private:
  uint32_t _internal_multipath_send_enabled() const;
  void _internal_set_multipath_send_enabled(uint32_t value);
  public:

  // optional uint64 packets_recv_out_of_order = 9;
  bool has_packets_recv_out_of_order() const;
  private:
  bool _internal_has_packets_recv_out_of_order() const;
  public:
  void clear_packets_recv_out_of_order();
  uint64_t packets_recv_out_of_order() const;
  void set_packets_recv_out_of_order(uint64_t value);
  private:
  uint64_t _internal_packets_recv_out_of_order() const;
  void _internal_set_packets_recv_out_of_order(uint64_t value);
  public:

  // optional uint64 packets_recv_duplicate = 10;
  bool has_packets_recv_duplicate() const;
  private:
  bool _internal_has_packets_recv_duplicate() const;
  public:
  void clear_packets_recv_duplicate();
  uint64_t packets_recv_duplicate() const;
  void set_packets_recv_duplicate(uint64_t value);
  private:
  uint64_t _internal_packets_recv_duplicate() const;
  void _internal_set_packets_recv_duplicate(uint64_t value);
  public:

  // optional uint64 packets_recv_lurch = 11;
  bool has_packets_recv_lurch() const;
  private:
  bool _internal_has_packets_recv_lurch() const;
  public:
  void clear_packets_recv_lurch();
  uint64_t packets_recv_lurch() const;
  void set_packets_recv_lurch(uint64_t value);
  private:
  uint64_t _internal_packets_recv_lurch() const;
  void _internal_set_packets_recv_lurch(uint64_t value);
  public:

  // optional uint64 packets_recv_out_of_order_corrected = 15;
  bool has_packets_recv_out_of_order_corrected() const;
  private:
  bool _internal_has_packets_recv_out_of_order_corrected() const;
  public:
  void clear_packets_recv_out_of_order_corrected();
  uint64_t packets_recv_out_of_order_corrected() const;
  void set_packets_recv_out_of_order_corrected(uint64_t value);
  private:
  uint64_t _internal_packets_recv_out_of_order_corrected() const;
  void _internal_set_packets_recv_out_of_order_corrected(uint64_t value);
  public:

  // optional uint32 quality_histogram_100 = 21;
  bool has_quality_histogram_100() const;
  private:
  bool _internal_has_quality_histogram_100() const;
  public:
  void clear_quality_histogram_100();
  uint32_t quality_histogram_100() const;
  void set_quality_histogram_100(uint32_t value);
  private:
  uint32_t _internal_quality_histogram_100() const;
  void _internal_set_quality_histogram_100(uint32_t value);
  public:

  // optional uint32 quality_histogram_99 = 22;
  bool has_quality_histogram_99() const;
  private:
  bool _internal_has_quality_histogram_99() const;
  public:
  void clear_quality_histogram_99();
  uint32_t quality_histogram_99() const;
  void set_quality_histogram_99(uint32_t value);
  private:
  uint32_t _internal_quality_histogram_99() const;
  void _internal_set_quality_histogram_99(uint32_t value);
  public:

  // optional uint32 quality_histogram_97 = 23;
  bool has_quality_histogram_97() const;
  private:
  bool _internal_has_quality_histogram_97() const;
  public:
  void clear_quality_histogram_97();
  uint32_t quality_histogram_97() const;
  void set_quality_histogram_97(uint32_t value);
  private:
  uint32_t _internal_quality_histogram_97() const;
  void _internal_set_quality_histogram_97(uint32_t value);
  public:

  // optional uint32 quality_histogram_95 = 24;
  bool has_quality_histogram_95() const;
  private:
  bool _internal_has_quality_histogram_95() const;
  public:
  void clear_quality_histogram_95();
  uint32_t quality_histogram_95() const;
  void set_quality_histogram_95(uint32_t value);
  private:
  uint32_t _internal_quality_histogram_95() const;
  void _internal_set_quality_histogram_95(uint32_t value);
  public:

  // optional uint32 quality_histogram_90 = 25;
  bool has_quality_histogram_90() const;
  private:
  bool _internal_has_quality_histogram_90() const;
  public:
  void clear_quality_histogram_90();
  uint32_t quality_histogram_90() const;
  void set_quality_histogram_90(uint32_t value);
  private:
  uint32_t _internal_quality_histogram_90() const;
  void _internal_set_quality_histogram_90(uint32_t value);
  public:

  // optional uint32 quality_histogram_75 = 26;
  bool has_quality_histogram_75() const;
  private:
  bool _internal_has_quality_histogram_75() const;
  public:
  void clear_quality_histogram_75();
  uint32_t quality_histogram_75() const;
  void set_quality_histogram_75(uint32_t value);
  private:
  uint32_t _internal_quality_histogram_75() const;
  void _internal_set_quality_histogram_75(uint32_t value);
  public:

  // optional uint32 quality_histogram_50 = 27;
  bool has_quality_histogram_50() const;
  private:
  bool _internal_has_quality_histogram_50() const;
  public:
  void clear_quality_histogram_50();
  uint32_t quality_histogram_50() const;
  void set_quality_histogram_50(uint32_t value);
  private:
  uint32_t _internal_quality_histogram_50() const;
  void _internal_set_quality_histogram_50(uint32_t value);
  public:

  // optional uint32 quality_histogram_1 = 28;
  bool has_quality_histogram_1() const;
  private:
  bool _internal_has_quality_histogram_1() const;
  public:
  void clear_quality_histogram_1();
  uint32_t quality_histogram_1() const;
  void set_quality_histogram_1(uint32_t value);
  private:
  uint32_t _internal_quality_histogram_1() const;
  void _internal_set_quality_histogram_1(uint32_t value);
  public:

  // optional uint32 quality_histogram_dead = 29;
  bool has_quality_histogram_dead() const;
  private:
  bool _internal_has_quality_histogram_dead() const;
  public:
  void clear_quality_histogram_dead();
  uint32_t quality_histogram_dead() const;
  void set_quality_histogram_dead(uint32_t value);
  private:
  uint32_t _internal_quality_histogram_dead() const;
  void _internal_set_quality_histogram_dead(uint32_t value);
  public:

  // optional uint32 quality_ntile_2nd = 30;
  bool has_quality_ntile_2nd() const;
  private:
  bool _internal_has_quality_ntile_2nd() const;
  public:
  void clear_quality_ntile_2nd();
  uint32_t quality_ntile_2nd() const;
  void set_quality_ntile_2nd(uint32_t value);
  private:
  uint32_t _internal_quality_ntile_2nd() const;
  void _internal_set_quality_ntile_2nd(uint32_t value);
  public:

  // optional uint32 quality_ntile_5th = 31;
  bool has_quality_ntile_5th() const;
  private:
  bool _internal_has_quality_ntile_5th() const;
  public:
  void clear_quality_ntile_5th();
  uint32_t quality_ntile_5th() const;
  void set_quality_ntile_5th(uint32_t value);
  private:
  uint32_t _internal_quality_ntile_5th() const;
  void _internal_set_quality_ntile_5th(uint32_t value);
  public:

  // optional uint32 quality_ntile_25th = 32;
  bool has_quality_ntile_25th() const;
  private:
  bool _internal_has_quality_ntile_25th() const;
  public:
  void clear_quality_ntile_25th();
  uint32_t quality_ntile_25th() const;
  void set_quality_ntile_25th(uint32_t value);
  private:
  uint32_t _internal_quality_ntile_25th() const;
  void _internal_set_quality_ntile_25th(uint32_t value);
  public:

  // optional uint32 quality_ntile_50th = 33;
  bool has_quality_ntile_50th() const;
  private:
  bool _internal_has_quality_ntile_50th() const;
  public:
  void clear_quality_ntile_50th();
  uint32_t quality_ntile_50th() const;
  void set_quality_ntile_50th(uint32_t value);
  private:
  uint32_t _internal_quality_ntile_50th() const;
  void _internal_set_quality_ntile_50th(uint32_t value);
  public:

  // optional uint32 ping_histogram_25 = 41;
  bool has_ping_histogram_25() const;
  private:
  bool _internal_has_ping_histogram_25() const;
  public:
  void clear_ping_histogram_25();
  uint32_t ping_histogram_25() const;
  void set_ping_histogram_25(uint32_t value);
  private:
  uint32_t _internal_ping_histogram_25() const;
  void _internal_set_ping_histogram_25(uint32_t value);
  public:

  // optional uint32 ping_histogram_50 = 42;
  bool has_ping_histogram_50() const;
  private:
  bool _internal_has_ping_histogram_50() const;
  public:
  void clear_ping_histogram_50();
  uint32_t ping_histogram_50() const;
  void set_ping_histogram_50(uint32_t value);
  private:
  uint32_t _internal_ping_histogram_50() const;
  void _internal_set_ping_histogram_50(uint32_t value);
  public:

  // optional uint32 ping_histogram_75 = 43;
  bool has_ping_histogram_75() const;
  private:
  bool _internal_has_ping_histogram_75() const;
  public:
  void clear_ping_histogram_75();
  uint32_t ping_histogram_75() const;
  void set_ping_histogram_75(uint32_t value);
  private:
  uint32_t _internal_ping_histogram_75() const;
  void _internal_set_ping_histogram_75(uint32_t value);
  public:

  // optional uint32 ping_histogram_100 = 44;
  bool has_ping_histogram_100() const;
  private:
  bool _internal_has_ping_histogram_100() const;
  public:
  void clear_ping_histogram_100();
  uint32_t ping_histogram_100() const;
  void set_ping_histogram_100(uint32_t value);
  private:
  uint32_t _internal_ping_histogram_100() const;
  void _internal_set_ping_histogram_100(uint32_t value);
  public:

  // optional uint32 ping_histogram_125 = 45;
  bool has_ping_histogram_125() const;
  private:
  bool _internal_has_ping_histogram_125() const;
  public:
  void clear_ping_histogram_125();
  uint32_t ping_histogram_125() const;
  void set_ping_histogram_125(uint32_t value);
  private:
  uint32_t _internal_ping_histogram_125() const;
  void _internal_set_ping_histogram_125(uint32_t value);
  public:

  // optional uint32 ping_histogram_150 = 46;
  bool has_ping_histogram_150() const;
  private:
  bool _internal_has_ping_histogram_150() const;
  public:
  void clear_ping_histogram_150();
  uint32_t ping_histogram_150() const;
  void set_ping_histogram_150(uint32_t value);
  private:
  uint32_t _internal_ping_histogram_150() const;
  void _internal_set_ping_histogram_150(uint32_t value);
  public:

  // optional uint32 ping_histogram_200 = 47;
  bool has_ping_histogram_200() const;
  private:
  bool _internal_has_ping_histogram_200() const;
  public:
  void clear_ping_histogram_200();
  uint32_t ping_histogram_200() const;
  void set_ping_histogram_200(uint32_t value);
  private:
  uint32_t _internal_ping_histogram_200() const;
  void _internal_set_ping_histogram_200(uint32_t value);
  public:

  // optional uint32 ping_histogram_300 = 48;
  bool has_ping_histogram_300() const;
  private:
  bool _internal_has_ping_histogram_300() const;
  public:
  void clear_ping_histogram_300();
  uint32_t ping_histogram_300() const;
  void set_ping_histogram_300(uint32_t value);
  private:
  uint32_t _internal_ping_histogram_300() const;
  void _internal_set_ping_histogram_300(uint32_t value);
  public:

  // optional uint32 ping_histogram_max = 49;
  bool has_ping_histogram_max() const;
  private:
  bool _internal_has_ping_histogram_max() const;
  public:
  void clear_ping_histogram_max();
  uint32_t ping_histogram_max() const;
  void set_ping_histogram_max(uint32_t value);
  private:
  uint32_t _internal_ping_histogram_max() const;
  void _internal_set_ping_histogram_max(uint32_t value);
  public:

  // optional uint32 ping_ntile_5th = 50;
  bool has_ping_ntile_5th() const;
  private:
  bool _internal_has_ping_ntile_5th() const;
  public:
  void clear_ping_ntile_5th();
  uint32_t ping_ntile_5th() const;
  void set_ping_ntile_5th(uint32_t value);
  private:
  uint32_t _internal_ping_ntile_5th() const;
  void _internal_set_ping_ntile_5th(uint32_t value);
  public:

  // optional uint32 ping_ntile_50th = 51;
  bool has_ping_ntile_50th() const;
  private:
  bool _internal_has_ping_ntile_50th() const;
  public:
  void clear_ping_ntile_50th();
  uint32_t ping_ntile_50th() const;
  void set_ping_ntile_50th(uint32_t value);
  private:
  uint32_t _internal_ping_ntile_50th() const;
  void _internal_set_ping_ntile_50th(uint32_t value);
  public:

  // optional uint32 ping_ntile_75th = 52;
  bool has_ping_ntile_75th() const;
  private:
  bool _internal_has_ping_ntile_75th() const;
  public:
  void clear_ping_ntile_75th();
  uint32_t ping_ntile_75th() const;
  void set_ping_ntile_75th(uint32_t value);
  private:
  uint32_t _internal_ping_ntile_75th() const;
  void _internal_set_ping_ntile_75th(uint32_t value);
  public:

  // optional uint32 ping_ntile_95th = 53;
  bool has_ping_ntile_95th() const;
  private:
  bool _internal_has_ping_ntile_95th() const;
  public:
  void clear_ping_ntile_95th();
  uint32_t ping_ntile_95th() const;
  void set_ping_ntile_95th(uint32_t value);
  private:
  uint32_t _internal_ping_ntile_95th() const;
  void _internal_set_ping_ntile_95th(uint32_t value);
  public:

  // optional uint32 ping_ntile_98th = 54;
  bool has_ping_ntile_98th() const;
  private:
  bool _internal_has_ping_ntile_98th() const;
  public:
  void clear_ping_ntile_98th();
  uint32_t ping_ntile_98th() const;
  void set_ping_ntile_98th(uint32_t value);
  private:
  uint32_t _internal_ping_ntile_98th() const;
  void _internal_set_ping_ntile_98th(uint32_t value);
  public:

  // optional uint32 jitter_histogram_negligible = 61;
  bool has_jitter_histogram_negligible() const;
  private:
  bool _internal_has_jitter_histogram_negligible() const;
  public:
  void clear_jitter_histogram_negligible();
  uint32_t jitter_histogram_negligible() const;
  void set_jitter_histogram_negligible(uint32_t value);
  private:
  uint32_t _internal_jitter_histogram_negligible() const;
  void _internal_set_jitter_histogram_negligible(uint32_t value);
  public:

  // optional uint32 jitter_histogram_1 = 62;
  bool has_jitter_histogram_1() const;
  private:
  bool _internal_has_jitter_histogram_1() const;
  public:
  void clear_jitter_histogram_1();
  uint32_t jitter_histogram_1() const;
  void set_jitter_histogram_1(uint32_t value);
  private:
  uint32_t _internal_jitter_histogram_1() const;
  void _internal_set_jitter_histogram_1(uint32_t value);
  public:

  // optional uint32 jitter_histogram_2 = 63;
  bool has_jitter_histogram_2() const;
  private:
  bool _internal_has_jitter_histogram_2() const;
  public:
  void clear_jitter_histogram_2();
  uint32_t jitter_histogram_2() const;
  void set_jitter_histogram_2(uint32_t value);
  private:
  uint32_t _internal_jitter_histogram_2() const;
  void _internal_set_jitter_histogram_2(uint32_t value);
  public:

  // optional uint32 jitter_histogram_5 = 64;
  bool has_jitter_histogram_5() const;
  private:
  bool _internal_has_jitter_histogram_5() const;
  public:
  void clear_jitter_histogram_5();
  uint32_t jitter_histogram_5() const;
  void set_jitter_histogram_5(uint32_t value);
  private:
  uint32_t _internal_jitter_histogram_5() const;
  void _internal_set_jitter_histogram_5(uint32_t value);
  public:

  // optional uint32 jitter_histogram_10 = 65;
  bool has_jitter_histogram_10() const;
  private:
  bool _internal_has_jitter_histogram_10() const;
  public:
  void clear_jitter_histogram_10();
  uint32_t jitter_histogram_10() const;
  void set_jitter_histogram_10(uint32_t value);
  private:
  uint32_t _internal_jitter_histogram_10() const;
  void _internal_set_jitter_histogram_10(uint32_t value);
  public:

  // optional uint32 jitter_histogram_20 = 66;
  bool has_jitter_histogram_20() const;
  private:
  bool _internal_has_jitter_histogram_20() const;
  public:
  void clear_jitter_histogram_20();
  uint32_t jitter_histogram_20() const;
  void set_jitter_histogram_20(uint32_t value);
  private:
  uint32_t _internal_jitter_histogram_20() const;
  void _internal_set_jitter_histogram_20(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgSteamDatagramLinkLifetimeStats)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<2> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t > multipath_packets_recv_sequenced_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t > multipath_packets_recv_later_;
    uint64_t packets_sent_;
    uint64_t kb_sent_;
    uint64_t packets_recv_;
    uint64_t kb_recv_;
    uint64_t packets_recv_sequenced_;
    uint64_t packets_recv_dropped_;
    uint32_t connected_seconds_;
    uint32_t multipath_send_enabled_;
    uint64_t packets_recv_out_of_order_;
    uint64_t packets_recv_duplicate_;
    uint64_t packets_recv_lurch_;
    uint64_t packets_recv_out_of_order_corrected_;
    uint32_t quality_histogram_100_;
    uint32_t quality_histogram_99_;
    uint32_t quality_histogram_97_;
    uint32_t quality_histogram_95_;
    uint32_t quality_histogram_90_;
    uint32_t quality_histogram_75_;
    uint32_t quality_histogram_50_;
    uint32_t quality_histogram_1_;
    uint32_t quality_histogram_dead_;
    uint32_t quality_ntile_2nd_;
    uint32_t quality_ntile_5th_;
    uint32_t quality_ntile_25th_;
    uint32_t quality_ntile_50th_;
    uint32_t ping_histogram_25_;
    uint32_t ping_histogram_50_;
    uint32_t ping_histogram_75_;
    uint32_t ping_histogram_100_;
    uint32_t ping_histogram_125_;
    uint32_t ping_histogram_150_;
    uint32_t ping_histogram_200_;
    uint32_t ping_histogram_300_;
    uint32_t ping_histogram_max_;
    uint32_t ping_ntile_5th_;
    uint32_t ping_ntile_50th_;
    uint32_t ping_ntile_75th_;
    uint32_t ping_ntile_95th_;
    uint32_t ping_ntile_98th_;
    uint32_t jitter_histogram_negligible_;
    uint32_t jitter_histogram_1_;
    uint32_t jitter_histogram_2_;
    uint32_t jitter_histogram_5_;
    uint32_t jitter_histogram_10_;
    uint32_t jitter_histogram_20_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_steamnetworkingsockets_5fmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgSteamDatagramConnectionQuality final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CMsgSteamDatagramConnectionQuality) */ {
 public:
  inline CMsgSteamDatagramConnectionQuality() : CMsgSteamDatagramConnectionQuality(nullptr) {}
  ~CMsgSteamDatagramConnectionQuality() override;
  explicit PROTOBUF_CONSTEXPR CMsgSteamDatagramConnectionQuality(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgSteamDatagramConnectionQuality(const CMsgSteamDatagramConnectionQuality& from);
  CMsgSteamDatagramConnectionQuality(CMsgSteamDatagramConnectionQuality&& from) noexcept
    : CMsgSteamDatagramConnectionQuality() {
    *this = ::std::move(from);
  }

  inline CMsgSteamDatagramConnectionQuality& operator=(const CMsgSteamDatagramConnectionQuality& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgSteamDatagramConnectionQuality& operator=(CMsgSteamDatagramConnectionQuality&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgSteamDatagramConnectionQuality& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgSteamDatagramConnectionQuality* internal_default_instance() {
    return reinterpret_cast<const CMsgSteamDatagramConnectionQuality*>(
               &_CMsgSteamDatagramConnectionQuality_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;

  friend void swap(CMsgSteamDatagramConnectionQuality& a, CMsgSteamDatagramConnectionQuality& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgSteamDatagramConnectionQuality* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgSteamDatagramConnectionQuality* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgSteamDatagramConnectionQuality* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgSteamDatagramConnectionQuality>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgSteamDatagramConnectionQuality& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgSteamDatagramConnectionQuality& from) {
    CMsgSteamDatagramConnectionQuality::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CMsgSteamDatagramConnectionQuality* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgSteamDatagramConnectionQuality";
  }
  protected:
  explicit CMsgSteamDatagramConnectionQuality(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kInstantaneousFieldNumber = 1,
    kLifetimeFieldNumber = 2,
  };
  // optional .CMsgSteamDatagramLinkInstantaneousStats instantaneous = 1;
  bool has_instantaneous() const;
  private:
  bool _internal_has_instantaneous() const;
  public:
  void clear_instantaneous();
  const ::CMsgSteamDatagramLinkInstantaneousStats& instantaneous() const;
  PROTOBUF_NODISCARD ::CMsgSteamDatagramLinkInstantaneousStats* release_instantaneous();
  ::CMsgSteamDatagramLinkInstantaneousStats* mutable_instantaneous();
  void set_allocated_instantaneous(::CMsgSteamDatagramLinkInstantaneousStats* instantaneous);
  private:
  const ::CMsgSteamDatagramLinkInstantaneousStats& _internal_instantaneous() const;
  ::CMsgSteamDatagramLinkInstantaneousStats* _internal_mutable_instantaneous();
  public:
  void unsafe_arena_set_allocated_instantaneous(
      ::CMsgSteamDatagramLinkInstantaneousStats* instantaneous);
  ::CMsgSteamDatagramLinkInstantaneousStats* unsafe_arena_release_instantaneous();

  // optional .CMsgSteamDatagramLinkLifetimeStats lifetime = 2;
  bool has_lifetime() const;
  private:
  bool _internal_has_lifetime() const;
  public:
  void clear_lifetime();
  const ::CMsgSteamDatagramLinkLifetimeStats& lifetime() const;
  PROTOBUF_NODISCARD ::CMsgSteamDatagramLinkLifetimeStats* release_lifetime();
  ::CMsgSteamDatagramLinkLifetimeStats* mutable_lifetime();
  void set_allocated_lifetime(::CMsgSteamDatagramLinkLifetimeStats* lifetime);
  private:
  const ::CMsgSteamDatagramLinkLifetimeStats& _internal_lifetime() const;
  ::CMsgSteamDatagramLinkLifetimeStats* _internal_mutable_lifetime();
  public:
  void unsafe_arena_set_allocated_lifetime(
      ::CMsgSteamDatagramLinkLifetimeStats* lifetime);
  ::CMsgSteamDatagramLinkLifetimeStats* unsafe_arena_release_lifetime();

  // @@protoc_insertion_point(class_scope:CMsgSteamDatagramConnectionQuality)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::CMsgSteamDatagramLinkInstantaneousStats* instantaneous_;
    ::CMsgSteamDatagramLinkLifetimeStats* lifetime_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_steamnetworkingsockets_5fmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgICECandidate final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CMsgICECandidate) */ {
 public:
  inline CMsgICECandidate() : CMsgICECandidate(nullptr) {}
  ~CMsgICECandidate() override;
  explicit PROTOBUF_CONSTEXPR CMsgICECandidate(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgICECandidate(const CMsgICECandidate& from);
  CMsgICECandidate(CMsgICECandidate&& from) noexcept
    : CMsgICECandidate() {
    *this = ::std::move(from);
  }

  inline CMsgICECandidate& operator=(const CMsgICECandidate& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgICECandidate& operator=(CMsgICECandidate&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgICECandidate& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgICECandidate* internal_default_instance() {
    return reinterpret_cast<const CMsgICECandidate*>(
               &_CMsgICECandidate_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    6;

  friend void swap(CMsgICECandidate& a, CMsgICECandidate& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgICECandidate* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgICECandidate* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgICECandidate* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgICECandidate>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgICECandidate& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgICECandidate& from) {
    CMsgICECandidate::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CMsgICECandidate* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgICECandidate";
  }
  protected:
  explicit CMsgICECandidate(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kCandidateFieldNumber = 3,
  };
  // optional string candidate = 3;
  bool has_candidate() const;
  private:
  bool _internal_has_candidate() const;
  public:
  void clear_candidate();
  const std::string& candidate() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_candidate(ArgT0&& arg0, ArgT... args);
  std::string* mutable_candidate();
  PROTOBUF_NODISCARD std::string* release_candidate();
  void set_allocated_candidate(std::string* candidate);
  private:
  const std::string& _internal_candidate() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_candidate(const std::string& value);
  std::string* _internal_mutable_candidate();
  public:

  // @@protoc_insertion_point(class_scope:CMsgICECandidate)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr candidate_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_steamnetworkingsockets_5fmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgICERendezvous_Auth final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CMsgICERendezvous.Auth) */ {
 public:
  inline CMsgICERendezvous_Auth() : CMsgICERendezvous_Auth(nullptr) {}
  ~CMsgICERendezvous_Auth() override;
  explicit PROTOBUF_CONSTEXPR CMsgICERendezvous_Auth(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgICERendezvous_Auth(const CMsgICERendezvous_Auth& from);
  CMsgICERendezvous_Auth(CMsgICERendezvous_Auth&& from) noexcept
    : CMsgICERendezvous_Auth() {
    *this = ::std::move(from);
  }

  inline CMsgICERendezvous_Auth& operator=(const CMsgICERendezvous_Auth& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgICERendezvous_Auth& operator=(CMsgICERendezvous_Auth&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgICERendezvous_Auth& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgICERendezvous_Auth* internal_default_instance() {
    return reinterpret_cast<const CMsgICERendezvous_Auth*>(
               &_CMsgICERendezvous_Auth_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    7;

  friend void swap(CMsgICERendezvous_Auth& a, CMsgICERendezvous_Auth& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgICERendezvous_Auth* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgICERendezvous_Auth* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgICERendezvous_Auth* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgICERendezvous_Auth>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgICERendezvous_Auth& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgICERendezvous_Auth& from) {
    CMsgICERendezvous_Auth::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CMsgICERendezvous_Auth* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgICERendezvous.Auth";
  }
  protected:
  explicit CMsgICERendezvous_Auth(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kPwdFragFieldNumber = 1,
  };
  // optional string pwd_frag = 1;
  bool has_pwd_frag() const;
  private:
  bool _internal_has_pwd_frag() const;
  public:
  void clear_pwd_frag();
  const std::string& pwd_frag() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_pwd_frag(ArgT0&& arg0, ArgT... args);
  std::string* mutable_pwd_frag();
  PROTOBUF_NODISCARD std::string* release_pwd_frag();
  void set_allocated_pwd_frag(std::string* pwd_frag);
  private:
  const std::string& _internal_pwd_frag() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_pwd_frag(const std::string& value);
  std::string* _internal_mutable_pwd_frag();
  public:

  // @@protoc_insertion_point(class_scope:CMsgICERendezvous.Auth)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pwd_frag_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_steamnetworkingsockets_5fmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgICERendezvous final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CMsgICERendezvous) */ {
 public:
  inline CMsgICERendezvous() : CMsgICERendezvous(nullptr) {}
  ~CMsgICERendezvous() override;
  explicit PROTOBUF_CONSTEXPR CMsgICERendezvous(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgICERendezvous(const CMsgICERendezvous& from);
  CMsgICERendezvous(CMsgICERendezvous&& from) noexcept
    : CMsgICERendezvous() {
    *this = ::std::move(from);
  }

  inline CMsgICERendezvous& operator=(const CMsgICERendezvous& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgICERendezvous& operator=(CMsgICERendezvous&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgICERendezvous& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgICERendezvous* internal_default_instance() {
    return reinterpret_cast<const CMsgICERendezvous*>(
               &_CMsgICERendezvous_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    8;

  friend void swap(CMsgICERendezvous& a, CMsgICERendezvous& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgICERendezvous* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgICERendezvous* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgICERendezvous* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgICERendezvous>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgICERendezvous& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgICERendezvous& from) {
    CMsgICERendezvous::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CMsgICERendezvous* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgICERendezvous";
  }
  protected:
  explicit CMsgICERendezvous(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef CMsgICERendezvous_Auth Auth;

  // accessors -------------------------------------------------------

  enum : int {
    kAddCandidateFieldNumber = 1,
    kAuthFieldNumber = 2,
  };
  // optional .CMsgICECandidate add_candidate = 1;
  bool has_add_candidate() const;
  private:
  bool _internal_has_add_candidate() const;
  public:
  void clear_add_candidate();
  const ::CMsgICECandidate& add_candidate() const;
  PROTOBUF_NODISCARD ::CMsgICECandidate* release_add_candidate();
  ::CMsgICECandidate* mutable_add_candidate();
  void set_allocated_add_candidate(::CMsgICECandidate* add_candidate);
  private:
  const ::CMsgICECandidate& _internal_add_candidate() const;
  ::CMsgICECandidate* _internal_mutable_add_candidate();
  public:
  void unsafe_arena_set_allocated_add_candidate(
      ::CMsgICECandidate* add_candidate);
  ::CMsgICECandidate* unsafe_arena_release_add_candidate();

  // optional .CMsgICERendezvous.Auth auth = 2;
  bool has_auth() const;
  private:
  bool _internal_has_auth() const;
  public:
  void clear_auth();
  const ::CMsgICERendezvous_Auth& auth() const;
  PROTOBUF_NODISCARD ::CMsgICERendezvous_Auth* release_auth();
  ::CMsgICERendezvous_Auth* mutable_auth();
  void set_allocated_auth(::CMsgICERendezvous_Auth* auth);
  private:
  const ::CMsgICERendezvous_Auth& _internal_auth() const;
  ::CMsgICERendezvous_Auth* _internal_mutable_auth();
  public:
  void unsafe_arena_set_allocated_auth(
      ::CMsgICERendezvous_Auth* auth);
  ::CMsgICERendezvous_Auth* unsafe_arena_release_auth();

  // @@protoc_insertion_point(class_scope:CMsgICERendezvous)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::CMsgICECandidate* add_candidate_;
    ::CMsgICERendezvous_Auth* auth_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_steamnetworkingsockets_5fmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgSteamNetworkingP2PRendezvous_ConnectRequest final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CMsgSteamNetworkingP2PRendezvous.ConnectRequest) */ {
 public:
  inline CMsgSteamNetworkingP2PRendezvous_ConnectRequest() : CMsgSteamNetworkingP2PRendezvous_ConnectRequest(nullptr) {}
  ~CMsgSteamNetworkingP2PRendezvous_ConnectRequest() override;
  explicit PROTOBUF_CONSTEXPR CMsgSteamNetworkingP2PRendezvous_ConnectRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgSteamNetworkingP2PRendezvous_ConnectRequest(const CMsgSteamNetworkingP2PRendezvous_ConnectRequest& from);
  CMsgSteamNetworkingP2PRendezvous_ConnectRequest(CMsgSteamNetworkingP2PRendezvous_ConnectRequest&& from) noexcept
    : CMsgSteamNetworkingP2PRendezvous_ConnectRequest() {
    *this = ::std::move(from);
  }

  inline CMsgSteamNetworkingP2PRendezvous_ConnectRequest& operator=(const CMsgSteamNetworkingP2PRendezvous_ConnectRequest& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgSteamNetworkingP2PRendezvous_ConnectRequest& operator=(CMsgSteamNetworkingP2PRendezvous_ConnectRequest&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgSteamNetworkingP2PRendezvous_ConnectRequest& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgSteamNetworkingP2PRendezvous_ConnectRequest* internal_default_instance() {
    return reinterpret_cast<const CMsgSteamNetworkingP2PRendezvous_ConnectRequest*>(
               &_CMsgSteamNetworkingP2PRendezvous_ConnectRequest_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    9;

  friend void swap(CMsgSteamNetworkingP2PRendezvous_ConnectRequest& a, CMsgSteamNetworkingP2PRendezvous_ConnectRequest& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgSteamNetworkingP2PRendezvous_ConnectRequest* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgSteamNetworkingP2PRendezvous_ConnectRequest* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgSteamNetworkingP2PRendezvous_ConnectRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgSteamNetworkingP2PRendezvous_ConnectRequest>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgSteamNetworkingP2PRendezvous_ConnectRequest& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgSteamNetworkingP2PRendezvous_ConnectRequest& from) {
    CMsgSteamNetworkingP2PRendezvous_ConnectRequest::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CMsgSteamNetworkingP2PRendezvous_ConnectRequest* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgSteamNetworkingP2PRendezvous.ConnectRequest";
  }
  protected:
  explicit CMsgSteamNetworkingP2PRendezvous_ConnectRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kFromFakeipFieldNumber = 11,
    kCryptFieldNumber = 6,
    kCertFieldNumber = 7,
    kToVirtualPortFieldNumber = 9,
    kFromVirtualPortFieldNumber = 10,
  };
  // optional string from_fakeip = 11;
  bool has_from_fakeip() const;
  private:
  bool _internal_has_from_fakeip() const;
  public:
  void clear_from_fakeip();
  const std::string& from_fakeip() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_from_fakeip(ArgT0&& arg0, ArgT... args);
  std::string* mutable_from_fakeip();
  PROTOBUF_NODISCARD std::string* release_from_fakeip();
  void set_allocated_from_fakeip(std::string* from_fakeip);
  private:
  const std::string& _internal_from_fakeip() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_from_fakeip(const std::string& value);
  std::string* _internal_mutable_from_fakeip();
  public:

  // optional .CMsgSteamDatagramSessionCryptInfoSigned crypt = 6;
  bool has_crypt() const;
  private:
  bool _internal_has_crypt() const;
  public:
  void clear_crypt();
  const ::CMsgSteamDatagramSessionCryptInfoSigned& crypt() const;
  PROTOBUF_NODISCARD ::CMsgSteamDatagramSessionCryptInfoSigned* release_crypt();
  ::CMsgSteamDatagramSessionCryptInfoSigned* mutable_crypt();
  void set_allocated_crypt(::CMsgSteamDatagramSessionCryptInfoSigned* crypt);
  private:
  const ::CMsgSteamDatagramSessionCryptInfoSigned& _internal_crypt() const;
  ::CMsgSteamDatagramSessionCryptInfoSigned* _internal_mutable_crypt();
  public:
  void unsafe_arena_set_allocated_crypt(
      ::CMsgSteamDatagramSessionCryptInfoSigned* crypt);
  ::CMsgSteamDatagramSessionCryptInfoSigned* unsafe_arena_release_crypt();

  // optional .CMsgSteamDatagramCertificateSigned cert = 7;
  bool has_cert() const;
  private:
  bool _internal_has_cert() const;
  public:
  void clear_cert();
  const ::CMsgSteamDatagramCertificateSigned& cert() const;
  PROTOBUF_NODISCARD ::CMsgSteamDatagramCertificateSigned* release_cert();
  ::CMsgSteamDatagramCertificateSigned* mutable_cert();
  void set_allocated_cert(::CMsgSteamDatagramCertificateSigned* cert);
  private:
  const ::CMsgSteamDatagramCertificateSigned& _internal_cert() const;
  ::CMsgSteamDatagramCertificateSigned* _internal_mutable_cert();
  public:
  void unsafe_arena_set_allocated_cert(
      ::CMsgSteamDatagramCertificateSigned* cert);
  ::CMsgSteamDatagramCertificateSigned* unsafe_arena_release_cert();

  // optional uint32 to_virtual_port = 9;
  bool has_to_virtual_port() const;
  private:
  bool _internal_has_to_virtual_port() const;
  public:
  void clear_to_virtual_port();
  uint32_t to_virtual_port() const;
  void set_to_virtual_port(uint32_t value);
  private:
  uint32_t _internal_to_virtual_port() const;
  void _internal_set_to_virtual_port(uint32_t value);
  public:

  // optional uint32 from_virtual_port = 10;
  bool has_from_virtual_port() const;
  private:
  bool _internal_has_from_virtual_port() const;
  public:
  void clear_from_virtual_port();
  uint32_t from_virtual_port() const;
  void set_from_virtual_port(uint32_t value);
  private:
  uint32_t _internal_from_virtual_port() const;
  void _internal_set_from_virtual_port(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgSteamNetworkingP2PRendezvous.ConnectRequest)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr from_fakeip_;
    ::CMsgSteamDatagramSessionCryptInfoSigned* crypt_;
    ::CMsgSteamDatagramCertificateSigned* cert_;
    uint32_t to_virtual_port_;
    uint32_t from_virtual_port_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_steamnetworkingsockets_5fmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgSteamNetworkingP2PRendezvous_ConnectOK final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CMsgSteamNetworkingP2PRendezvous.ConnectOK) */ {
 public:
  inline CMsgSteamNetworkingP2PRendezvous_ConnectOK() : CMsgSteamNetworkingP2PRendezvous_ConnectOK(nullptr) {}
  ~CMsgSteamNetworkingP2PRendezvous_ConnectOK() override;
  explicit PROTOBUF_CONSTEXPR CMsgSteamNetworkingP2PRendezvous_ConnectOK(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgSteamNetworkingP2PRendezvous_ConnectOK(const CMsgSteamNetworkingP2PRendezvous_ConnectOK& from);
  CMsgSteamNetworkingP2PRendezvous_ConnectOK(CMsgSteamNetworkingP2PRendezvous_ConnectOK&& from) noexcept
    : CMsgSteamNetworkingP2PRendezvous_ConnectOK() {
    *this = ::std::move(from);
  }

  inline CMsgSteamNetworkingP2PRendezvous_ConnectOK& operator=(const CMsgSteamNetworkingP2PRendezvous_ConnectOK& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgSteamNetworkingP2PRendezvous_ConnectOK& operator=(CMsgSteamNetworkingP2PRendezvous_ConnectOK&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgSteamNetworkingP2PRendezvous_ConnectOK& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgSteamNetworkingP2PRendezvous_ConnectOK* internal_default_instance() {
    return reinterpret_cast<const CMsgSteamNetworkingP2PRendezvous_ConnectOK*>(
               &_CMsgSteamNetworkingP2PRendezvous_ConnectOK_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    10;

  friend void swap(CMsgSteamNetworkingP2PRendezvous_ConnectOK& a, CMsgSteamNetworkingP2PRendezvous_ConnectOK& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgSteamNetworkingP2PRendezvous_ConnectOK* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgSteamNetworkingP2PRendezvous_ConnectOK* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgSteamNetworkingP2PRendezvous_ConnectOK* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgSteamNetworkingP2PRendezvous_ConnectOK>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgSteamNetworkingP2PRendezvous_ConnectOK& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgSteamNetworkingP2PRendezvous_ConnectOK& from) {
    CMsgSteamNetworkingP2PRendezvous_ConnectOK::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CMsgSteamNetworkingP2PRendezvous_ConnectOK* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgSteamNetworkingP2PRendezvous.ConnectOK";
  }
  protected:
  explicit CMsgSteamNetworkingP2PRendezvous_ConnectOK(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kCryptFieldNumber = 5,
    kCertFieldNumber = 6,
  };
  // optional .CMsgSteamDatagramSessionCryptInfoSigned crypt = 5;
  bool has_crypt() const;
  private:
  bool _internal_has_crypt() const;
  public:
  void clear_crypt();
  const ::CMsgSteamDatagramSessionCryptInfoSigned& crypt() const;
  PROTOBUF_NODISCARD ::CMsgSteamDatagramSessionCryptInfoSigned* release_crypt();
  ::CMsgSteamDatagramSessionCryptInfoSigned* mutable_crypt();
  void set_allocated_crypt(::CMsgSteamDatagramSessionCryptInfoSigned* crypt);
  private:
  const ::CMsgSteamDatagramSessionCryptInfoSigned& _internal_crypt() const;
  ::CMsgSteamDatagramSessionCryptInfoSigned* _internal_mutable_crypt();
  public:
  void unsafe_arena_set_allocated_crypt(
      ::CMsgSteamDatagramSessionCryptInfoSigned* crypt);
  ::CMsgSteamDatagramSessionCryptInfoSigned* unsafe_arena_release_crypt();

  // optional .CMsgSteamDatagramCertificateSigned cert = 6;
  bool has_cert() const;
  private:
  bool _internal_has_cert() const;
  public:
  void clear_cert();
  const ::CMsgSteamDatagramCertificateSigned& cert() const;
  PROTOBUF_NODISCARD ::CMsgSteamDatagramCertificateSigned* release_cert();
  ::CMsgSteamDatagramCertificateSigned* mutable_cert();
  void set_allocated_cert(::CMsgSteamDatagramCertificateSigned* cert);
  private:
  const ::CMsgSteamDatagramCertificateSigned& _internal_cert() const;
  ::CMsgSteamDatagramCertificateSigned* _internal_mutable_cert();
  public:
  void unsafe_arena_set_allocated_cert(
      ::CMsgSteamDatagramCertificateSigned* cert);
  ::CMsgSteamDatagramCertificateSigned* unsafe_arena_release_cert();

  // @@protoc_insertion_point(class_scope:CMsgSteamNetworkingP2PRendezvous.ConnectOK)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::CMsgSteamDatagramSessionCryptInfoSigned* crypt_;
    ::CMsgSteamDatagramCertificateSigned* cert_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_steamnetworkingsockets_5fmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgSteamNetworkingP2PRendezvous_ConnectionClosed final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CMsgSteamNetworkingP2PRendezvous.ConnectionClosed) */ {
 public:
  inline CMsgSteamNetworkingP2PRendezvous_ConnectionClosed() : CMsgSteamNetworkingP2PRendezvous_ConnectionClosed(nullptr) {}
  ~CMsgSteamNetworkingP2PRendezvous_ConnectionClosed() override;
  explicit PROTOBUF_CONSTEXPR CMsgSteamNetworkingP2PRendezvous_ConnectionClosed(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgSteamNetworkingP2PRendezvous_ConnectionClosed(const CMsgSteamNetworkingP2PRendezvous_ConnectionClosed& from);
  CMsgSteamNetworkingP2PRendezvous_ConnectionClosed(CMsgSteamNetworkingP2PRendezvous_ConnectionClosed&& from) noexcept
    : CMsgSteamNetworkingP2PRendezvous_ConnectionClosed() {
    *this = ::std::move(from);
  }

  inline CMsgSteamNetworkingP2PRendezvous_ConnectionClosed& operator=(const CMsgSteamNetworkingP2PRendezvous_ConnectionClosed& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgSteamNetworkingP2PRendezvous_ConnectionClosed& operator=(CMsgSteamNetworkingP2PRendezvous_ConnectionClosed&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgSteamNetworkingP2PRendezvous_ConnectionClosed& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgSteamNetworkingP2PRendezvous_ConnectionClosed* internal_default_instance() {
    return reinterpret_cast<const CMsgSteamNetworkingP2PRendezvous_ConnectionClosed*>(
               &_CMsgSteamNetworkingP2PRendezvous_ConnectionClosed_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    11;

  friend void swap(CMsgSteamNetworkingP2PRendezvous_ConnectionClosed& a, CMsgSteamNetworkingP2PRendezvous_ConnectionClosed& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgSteamNetworkingP2PRendezvous_ConnectionClosed* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgSteamNetworkingP2PRendezvous_ConnectionClosed* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgSteamNetworkingP2PRendezvous_ConnectionClosed* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgSteamNetworkingP2PRendezvous_ConnectionClosed>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgSteamNetworkingP2PRendezvous_ConnectionClosed& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgSteamNetworkingP2PRendezvous_ConnectionClosed& from) {
    CMsgSteamNetworkingP2PRendezvous_ConnectionClosed::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CMsgSteamNetworkingP2PRendezvous_ConnectionClosed* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgSteamNetworkingP2PRendezvous.ConnectionClosed";
  }
  protected:
  explicit CMsgSteamNetworkingP2PRendezvous_ConnectionClosed(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kDebugFieldNumber = 5,
    kReasonCodeFieldNumber = 6,
  };
  // optional string debug = 5;
  bool has_debug() const;
  private:
  bool _internal_has_debug() const;
  public:
  void clear_debug();
  const std::string& debug() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_debug(ArgT0&& arg0, ArgT... args);
  std::string* mutable_debug();
  PROTOBUF_NODISCARD std::string* release_debug();
  void set_allocated_debug(std::string* debug);
  private:
  const std::string& _internal_debug() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_debug(const std::string& value);
  std::string* _internal_mutable_debug();
  public:

  // optional uint32 reason_code = 6;
  bool has_reason_code() const;
  private:
  bool _internal_has_reason_code() const;
  public:
  void clear_reason_code();
  uint32_t reason_code() const;
  void set_reason_code(uint32_t value);
  private:
  uint32_t _internal_reason_code() const;
  void _internal_set_reason_code(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgSteamNetworkingP2PRendezvous.ConnectionClosed)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr debug_;
    uint32_t reason_code_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_steamnetworkingsockets_5fmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgSteamNetworkingP2PRendezvous_ReliableMessage final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CMsgSteamNetworkingP2PRendezvous.ReliableMessage) */ {
 public:
  inline CMsgSteamNetworkingP2PRendezvous_ReliableMessage() : CMsgSteamNetworkingP2PRendezvous_ReliableMessage(nullptr) {}
  ~CMsgSteamNetworkingP2PRendezvous_ReliableMessage() override;
  explicit PROTOBUF_CONSTEXPR CMsgSteamNetworkingP2PRendezvous_ReliableMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgSteamNetworkingP2PRendezvous_ReliableMessage(const CMsgSteamNetworkingP2PRendezvous_ReliableMessage& from);
  CMsgSteamNetworkingP2PRendezvous_ReliableMessage(CMsgSteamNetworkingP2PRendezvous_ReliableMessage&& from) noexcept
    : CMsgSteamNetworkingP2PRendezvous_ReliableMessage() {
    *this = ::std::move(from);
  }

  inline CMsgSteamNetworkingP2PRendezvous_ReliableMessage& operator=(const CMsgSteamNetworkingP2PRendezvous_ReliableMessage& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgSteamNetworkingP2PRendezvous_ReliableMessage& operator=(CMsgSteamNetworkingP2PRendezvous_ReliableMessage&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgSteamNetworkingP2PRendezvous_ReliableMessage& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgSteamNetworkingP2PRendezvous_ReliableMessage* internal_default_instance() {
    return reinterpret_cast<const CMsgSteamNetworkingP2PRendezvous_ReliableMessage*>(
               &_CMsgSteamNetworkingP2PRendezvous_ReliableMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    12;

  friend void swap(CMsgSteamNetworkingP2PRendezvous_ReliableMessage& a, CMsgSteamNetworkingP2PRendezvous_ReliableMessage& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgSteamNetworkingP2PRendezvous_ReliableMessage* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgSteamNetworkingP2PRendezvous_ReliableMessage* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgSteamNetworkingP2PRendezvous_ReliableMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgSteamNetworkingP2PRendezvous_ReliableMessage>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgSteamNetworkingP2PRendezvous_ReliableMessage& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgSteamNetworkingP2PRendezvous_ReliableMessage& from) {
    CMsgSteamNetworkingP2PRendezvous_ReliableMessage::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CMsgSteamNetworkingP2PRendezvous_ReliableMessage* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgSteamNetworkingP2PRendezvous.ReliableMessage";
  }
  protected:
  explicit CMsgSteamNetworkingP2PRendezvous_ReliableMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kIceFieldNumber = 1,
  };
  // optional .CMsgICERendezvous ice = 1;
  bool has_ice() const;
  private:
  bool _internal_has_ice() const;
  public:
  void clear_ice();
  const ::CMsgICERendezvous& ice() const;
  PROTOBUF_NODISCARD ::CMsgICERendezvous* release_ice();
  ::CMsgICERendezvous* mutable_ice();
  void set_allocated_ice(::CMsgICERendezvous* ice);
  private:
  const ::CMsgICERendezvous& _internal_ice() const;
  ::CMsgICERendezvous* _internal_mutable_ice();
  public:
  void unsafe_arena_set_allocated_ice(
      ::CMsgICERendezvous* ice);
  ::CMsgICERendezvous* unsafe_arena_release_ice();

  // @@protoc_insertion_point(class_scope:CMsgSteamNetworkingP2PRendezvous.ReliableMessage)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::CMsgICERendezvous* ice_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_steamnetworkingsockets_5fmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgSteamNetworkingP2PRendezvous_ApplicationMessage final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CMsgSteamNetworkingP2PRendezvous.ApplicationMessage) */ {
 public:
  inline CMsgSteamNetworkingP2PRendezvous_ApplicationMessage() : CMsgSteamNetworkingP2PRendezvous_ApplicationMessage(nullptr) {}
  ~CMsgSteamNetworkingP2PRendezvous_ApplicationMessage() override;
  explicit PROTOBUF_CONSTEXPR CMsgSteamNetworkingP2PRendezvous_ApplicationMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgSteamNetworkingP2PRendezvous_ApplicationMessage(const CMsgSteamNetworkingP2PRendezvous_ApplicationMessage& from);
  CMsgSteamNetworkingP2PRendezvous_ApplicationMessage(CMsgSteamNetworkingP2PRendezvous_ApplicationMessage&& from) noexcept
    : CMsgSteamNetworkingP2PRendezvous_ApplicationMessage() {
    *this = ::std::move(from);
  }

  inline CMsgSteamNetworkingP2PRendezvous_ApplicationMessage& operator=(const CMsgSteamNetworkingP2PRendezvous_ApplicationMessage& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgSteamNetworkingP2PRendezvous_ApplicationMessage& operator=(CMsgSteamNetworkingP2PRendezvous_ApplicationMessage&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgSteamNetworkingP2PRendezvous_ApplicationMessage& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgSteamNetworkingP2PRendezvous_ApplicationMessage* internal_default_instance() {
    return reinterpret_cast<const CMsgSteamNetworkingP2PRendezvous_ApplicationMessage*>(
               &_CMsgSteamNetworkingP2PRendezvous_ApplicationMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    13;

  friend void swap(CMsgSteamNetworkingP2PRendezvous_ApplicationMessage& a, CMsgSteamNetworkingP2PRendezvous_ApplicationMessage& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgSteamNetworkingP2PRendezvous_ApplicationMessage* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgSteamNetworkingP2PRendezvous_ApplicationMessage* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgSteamNetworkingP2PRendezvous_ApplicationMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgSteamNetworkingP2PRendezvous_ApplicationMessage>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgSteamNetworkingP2PRendezvous_ApplicationMessage& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgSteamNetworkingP2PRendezvous_ApplicationMessage& from) {
    CMsgSteamNetworkingP2PRendezvous_ApplicationMessage::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CMsgSteamNetworkingP2PRendezvous_ApplicationMessage* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgSteamNetworkingP2PRendezvous.ApplicationMessage";
  }
  protected:
  explicit CMsgSteamNetworkingP2PRendezvous_ApplicationMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kDataFieldNumber = 1,
    kMsgNumFieldNumber = 2,
    kFlagsFieldNumber = 3,
    kLaneIdxFieldNumber = 4,
  };
  // optional bytes data = 1;
  bool has_data() const;
  private:
  bool _internal_has_data() const;
  public:
  void clear_data();
  const std::string& data() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_data(ArgT0&& arg0, ArgT... args);
  std::string* mutable_data();
  PROTOBUF_NODISCARD std::string* release_data();
  void set_allocated_data(std::string* data);
  private:
  const std::string& _internal_data() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_data(const std::string& value);
  std::string* _internal_mutable_data();
  public:

  // optional uint64 msg_num = 2;
  bool has_msg_num() const;
  private:
  bool _internal_has_msg_num() const;
  public:
  void clear_msg_num();
  uint64_t msg_num() const;
  void set_msg_num(uint64_t value);
  private:
  uint64_t _internal_msg_num() const;
  void _internal_set_msg_num(uint64_t value);
  public:

  // optional uint32 flags = 3;
  bool has_flags() const;
  private:
  bool _internal_has_flags() const;
  public:
  void clear_flags();
  uint32_t flags() const;
  void set_flags(uint32_t value);
  private:
  uint32_t _internal_flags() const;
  void _internal_set_flags(uint32_t value);
  public:

  // optional uint32 lane_idx = 4;
  bool has_lane_idx() const;
  private:
  bool _internal_has_lane_idx() const;
  public:
  void clear_lane_idx();
  uint32_t lane_idx() const;
  void set_lane_idx(uint32_t value);
  private:
  uint32_t _internal_lane_idx() const;
  void _internal_set_lane_idx(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgSteamNetworkingP2PRendezvous.ApplicationMessage)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr data_;
    uint64_t msg_num_;
    uint32_t flags_;
    uint32_t lane_idx_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_steamnetworkingsockets_5fmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgSteamNetworkingP2PRendezvous final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CMsgSteamNetworkingP2PRendezvous) */ {
 public:
  inline CMsgSteamNetworkingP2PRendezvous() : CMsgSteamNetworkingP2PRendezvous(nullptr) {}
  ~CMsgSteamNetworkingP2PRendezvous() override;
  explicit PROTOBUF_CONSTEXPR CMsgSteamNetworkingP2PRendezvous(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgSteamNetworkingP2PRendezvous(const CMsgSteamNetworkingP2PRendezvous& from);
  CMsgSteamNetworkingP2PRendezvous(CMsgSteamNetworkingP2PRendezvous&& from) noexcept
    : CMsgSteamNetworkingP2PRendezvous() {
    *this = ::std::move(from);
  }

  inline CMsgSteamNetworkingP2PRendezvous& operator=(const CMsgSteamNetworkingP2PRendezvous& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgSteamNetworkingP2PRendezvous& operator=(CMsgSteamNetworkingP2PRendezvous&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgSteamNetworkingP2PRendezvous& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgSteamNetworkingP2PRendezvous* internal_default_instance() {
    return reinterpret_cast<const CMsgSteamNetworkingP2PRendezvous*>(
               &_CMsgSteamNetworkingP2PRendezvous_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    14;

  friend void swap(CMsgSteamNetworkingP2PRendezvous& a, CMsgSteamNetworkingP2PRendezvous& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgSteamNetworkingP2PRendezvous* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgSteamNetworkingP2PRendezvous* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgSteamNetworkingP2PRendezvous* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgSteamNetworkingP2PRendezvous>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgSteamNetworkingP2PRendezvous& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgSteamNetworkingP2PRendezvous& from) {
    CMsgSteamNetworkingP2PRendezvous::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CMsgSteamNetworkingP2PRendezvous* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgSteamNetworkingP2PRendezvous";
  }
  protected:
  explicit CMsgSteamNetworkingP2PRendezvous(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef CMsgSteamNetworkingP2PRendezvous_ConnectRequest ConnectRequest;
  typedef CMsgSteamNetworkingP2PRendezvous_ConnectOK ConnectOK;
  typedef CMsgSteamNetworkingP2PRendezvous_ConnectionClosed ConnectionClosed;
  typedef CMsgSteamNetworkingP2PRendezvous_ReliableMessage ReliableMessage;
  typedef CMsgSteamNetworkingP2PRendezvous_ApplicationMessage ApplicationMessage;

  // accessors -------------------------------------------------------

  enum : int {
    kReliableMessagesFieldNumber = 13,
    kApplicationMessagesFieldNumber = 15,
    kSdrRoutesFieldNumber = 2,
    kFromIdentityFieldNumber = 8,
    kToIdentityFieldNumber = 10,
    kHostedServerTicketFieldNumber = 14,
    kConnectRequestFieldNumber = 4,
    kConnectOkFieldNumber = 5,
    kConnectionClosedFieldNumber = 6,
    kToConnectionIdFieldNumber = 1,
    kAckPeerRoutesRevisionFieldNumber = 3,
    kIceEnabledFieldNumber = 7,
    kFromConnectionIdFieldNumber = 9,
    kAckReliableMsgFieldNumber = 11,
    kFirstReliableMsgFieldNumber = 12,
  };
  // repeated .CMsgSteamNetworkingP2PRendezvous.ReliableMessage reliable_messages = 13;
  int reliable_messages_size() const;
  private:
  int _internal_reliable_messages_size() const;
  public:
  void clear_reliable_messages();
  ::CMsgSteamNetworkingP2PRendezvous_ReliableMessage* mutable_reliable_messages(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgSteamNetworkingP2PRendezvous_ReliableMessage >*
      mutable_reliable_messages();
  private:
  const ::CMsgSteamNetworkingP2PRendezvous_ReliableMessage& _internal_reliable_messages(int index) const;
  ::CMsgSteamNetworkingP2PRendezvous_ReliableMessage* _internal_add_reliable_messages();
  public:
  const ::CMsgSteamNetworkingP2PRendezvous_ReliableMessage& reliable_messages(int index) const;
  ::CMsgSteamNetworkingP2PRendezvous_ReliableMessage* add_reliable_messages();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgSteamNetworkingP2PRendezvous_ReliableMessage >&
      reliable_messages() const;

  // repeated .CMsgSteamNetworkingP2PRendezvous.ApplicationMessage application_messages = 15;
  int application_messages_size() const;
  private:
  int _internal_application_messages_size() const;
  public:
  void clear_application_messages();
  ::CMsgSteamNetworkingP2PRendezvous_ApplicationMessage* mutable_application_messages(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgSteamNetworkingP2PRendezvous_ApplicationMessage >*
      mutable_application_messages();
  private:
  const ::CMsgSteamNetworkingP2PRendezvous_ApplicationMessage& _internal_application_messages(int index) const;
  ::CMsgSteamNetworkingP2PRendezvous_ApplicationMessage* _internal_add_application_messages();
  public:
  const ::CMsgSteamNetworkingP2PRendezvous_ApplicationMessage& application_messages(int index) const;
  ::CMsgSteamNetworkingP2PRendezvous_ApplicationMessage* add_application_messages();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgSteamNetworkingP2PRendezvous_ApplicationMessage >&
      application_messages() const;

  // optional bytes sdr_routes = 2;
  bool has_sdr_routes() const;
  private:
  bool _internal_has_sdr_routes() const;
  public:
  void clear_sdr_routes();
  const std::string& sdr_routes() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_sdr_routes(ArgT0&& arg0, ArgT... args);
  std::string* mutable_sdr_routes();
  PROTOBUF_NODISCARD std::string* release_sdr_routes();
  void set_allocated_sdr_routes(std::string* sdr_routes);
  private:
  const std::string& _internal_sdr_routes() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_sdr_routes(const std::string& value);
  std::string* _internal_mutable_sdr_routes();
  public:

  // optional string from_identity = 8;
  bool has_from_identity() const;
  private:
  bool _internal_has_from_identity() const;
  public:
  void clear_from_identity();
  const std::string& from_identity() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_from_identity(ArgT0&& arg0, ArgT... args);
  std::string* mutable_from_identity();
  PROTOBUF_NODISCARD std::string* release_from_identity();
  void set_allocated_from_identity(std::string* from_identity);
  private:
  const std::string& _internal_from_identity() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_from_identity(const std::string& value);
  std::string* _internal_mutable_from_identity();
  public:

  // optional string to_identity = 10;
  bool has_to_identity() const;
  private:
  bool _internal_has_to_identity() const;
  public:
  void clear_to_identity();
  const std::string& to_identity() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_to_identity(ArgT0&& arg0, ArgT... args);
  std::string* mutable_to_identity();
  PROTOBUF_NODISCARD std::string* release_to_identity();
  void set_allocated_to_identity(std::string* to_identity);
  private:
  const std::string& _internal_to_identity() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_to_identity(const std::string& value);
  std::string* _internal_mutable_to_identity();
  public:

  // optional bytes hosted_server_ticket = 14;
  bool has_hosted_server_ticket() const;
  private:
  bool _internal_has_hosted_server_ticket() const;
  public:
  void clear_hosted_server_ticket();
  const std::string& hosted_server_ticket() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_hosted_server_ticket(ArgT0&& arg0, ArgT... args);
  std::string* mutable_hosted_server_ticket();
  PROTOBUF_NODISCARD std::string* release_hosted_server_ticket();
  void set_allocated_hosted_server_ticket(std::string* hosted_server_ticket);
  private:
  const std::string& _internal_hosted_server_ticket() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_hosted_server_ticket(const std::string& value);
  std::string* _internal_mutable_hosted_server_ticket();
  public:

  // optional .CMsgSteamNetworkingP2PRendezvous.ConnectRequest connect_request = 4;
  bool has_connect_request() const;
  private:
  bool _internal_has_connect_request() const;
  public:
  void clear_connect_request();
  const ::CMsgSteamNetworkingP2PRendezvous_ConnectRequest& connect_request() const;
  PROTOBUF_NODISCARD ::CMsgSteamNetworkingP2PRendezvous_ConnectRequest* release_connect_request();
  ::CMsgSteamNetworkingP2PRendezvous_ConnectRequest* mutable_connect_request();
  void set_allocated_connect_request(::CMsgSteamNetworkingP2PRendezvous_ConnectRequest* connect_request);
  private:
  const ::CMsgSteamNetworkingP2PRendezvous_ConnectRequest& _internal_connect_request() const;
  ::CMsgSteamNetworkingP2PRendezvous_ConnectRequest* _internal_mutable_connect_request();
  public:
  void unsafe_arena_set_allocated_connect_request(
      ::CMsgSteamNetworkingP2PRendezvous_ConnectRequest* connect_request);
  ::CMsgSteamNetworkingP2PRendezvous_ConnectRequest* unsafe_arena_release_connect_request();

  // optional .CMsgSteamNetworkingP2PRendezvous.ConnectOK connect_ok = 5;
  bool has_connect_ok() const;
  private:
  bool _internal_has_connect_ok() const;
  public:
  void clear_connect_ok();
  const ::CMsgSteamNetworkingP2PRendezvous_ConnectOK& connect_ok() const;
  PROTOBUF_NODISCARD ::CMsgSteamNetworkingP2PRendezvous_ConnectOK* release_connect_ok();
  ::CMsgSteamNetworkingP2PRendezvous_ConnectOK* mutable_connect_ok();
  void set_allocated_connect_ok(::CMsgSteamNetworkingP2PRendezvous_ConnectOK* connect_ok);
  private:
  const ::CMsgSteamNetworkingP2PRendezvous_ConnectOK& _internal_connect_ok() const;
  ::CMsgSteamNetworkingP2PRendezvous_ConnectOK* _internal_mutable_connect_ok();
  public:
  void unsafe_arena_set_allocated_connect_ok(
      ::CMsgSteamNetworkingP2PRendezvous_ConnectOK* connect_ok);
  ::CMsgSteamNetworkingP2PRendezvous_ConnectOK* unsafe_arena_release_connect_ok();

  // optional .CMsgSteamNetworkingP2PRendezvous.ConnectionClosed connection_closed = 6;
  bool has_connection_closed() const;
  private:
  bool _internal_has_connection_closed() const;
  public:
  void clear_connection_closed();
  const ::CMsgSteamNetworkingP2PRendezvous_ConnectionClosed& connection_closed() const;
  PROTOBUF_NODISCARD ::CMsgSteamNetworkingP2PRendezvous_ConnectionClosed* release_connection_closed();
  ::CMsgSteamNetworkingP2PRendezvous_ConnectionClosed* mutable_connection_closed();
  void set_allocated_connection_closed(::CMsgSteamNetworkingP2PRendezvous_ConnectionClosed* connection_closed);
  private:
  const ::CMsgSteamNetworkingP2PRendezvous_ConnectionClosed& _internal_connection_closed() const;
  ::CMsgSteamNetworkingP2PRendezvous_ConnectionClosed* _internal_mutable_connection_closed();
  public:
  void unsafe_arena_set_allocated_connection_closed(
      ::CMsgSteamNetworkingP2PRendezvous_ConnectionClosed* connection_closed);
  ::CMsgSteamNetworkingP2PRendezvous_ConnectionClosed* unsafe_arena_release_connection_closed();

  // optional fixed32 to_connection_id = 1;
  bool has_to_connection_id() const;
  private:
  bool _internal_has_to_connection_id() const;
  public:
  void clear_to_connection_id();
  uint32_t to_connection_id() const;
  void set_to_connection_id(uint32_t value);
  private:
  uint32_t _internal_to_connection_id() const;
  void _internal_set_to_connection_id(uint32_t value);
  public:

  // optional uint32 ack_peer_routes_revision = 3;
  bool has_ack_peer_routes_revision() const;
  private:
  bool _internal_has_ack_peer_routes_revision() const;
  public:
  void clear_ack_peer_routes_revision();
  uint32_t ack_peer_routes_revision() const;
  void set_ack_peer_routes_revision(uint32_t value);
  private:
  uint32_t _internal_ack_peer_routes_revision() const;
  void _internal_set_ack_peer_routes_revision(uint32_t value);
  public:

  // optional bool ice_enabled = 7;
  bool has_ice_enabled() const;
  private:
  bool _internal_has_ice_enabled() const;
  public:
  void clear_ice_enabled();
  bool ice_enabled() const;
  void set_ice_enabled(bool value);
  private:
  bool _internal_ice_enabled() const;
  void _internal_set_ice_enabled(bool value);
  public:

  // optional fixed32 from_connection_id = 9;
  bool has_from_connection_id() const;
  private:
  bool _internal_has_from_connection_id() const;
  public:
  void clear_from_connection_id();
  uint32_t from_connection_id() const;
  void set_from_connection_id(uint32_t value);
  private:
  uint32_t _internal_from_connection_id() const;
  void _internal_set_from_connection_id(uint32_t value);
  public:

  // optional uint32 ack_reliable_msg = 11;
  bool has_ack_reliable_msg() const;
  private:
  bool _internal_has_ack_reliable_msg() const;
  public:
  void clear_ack_reliable_msg();
  uint32_t ack_reliable_msg() const;
  void set_ack_reliable_msg(uint32_t value);
  private:
  uint32_t _internal_ack_reliable_msg() const;
  void _internal_set_ack_reliable_msg(uint32_t value);
  public:

  // optional uint32 first_reliable_msg = 12;
  bool has_first_reliable_msg() const;
  private:
  bool _internal_has_first_reliable_msg() const;
  public:
  void clear_first_reliable_msg();
  uint32_t first_reliable_msg() const;
  void set_first_reliable_msg(uint32_t value);
  private:
  uint32_t _internal_first_reliable_msg() const;
  void _internal_set_first_reliable_msg(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgSteamNetworkingP2PRendezvous)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgSteamNetworkingP2PRendezvous_ReliableMessage > reliable_messages_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgSteamNetworkingP2PRendezvous_ApplicationMessage > application_messages_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr sdr_routes_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr from_identity_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr to_identity_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr hosted_server_ticket_;
    ::CMsgSteamNetworkingP2PRendezvous_ConnectRequest* connect_request_;
    ::CMsgSteamNetworkingP2PRendezvous_ConnectOK* connect_ok_;
    ::CMsgSteamNetworkingP2PRendezvous_ConnectionClosed* connection_closed_;
    uint32_t to_connection_id_;
    uint32_t ack_peer_routes_revision_;
    bool ice_enabled_;
    uint32_t from_connection_id_;
    uint32_t ack_reliable_msg_;
    uint32_t first_reliable_msg_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_steamnetworkingsockets_5fmessages_2eproto;
};
// -------------------------------------------------------------------

class CMsgSteamNetworkingICESessionSummary final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:CMsgSteamNetworkingICESessionSummary) */ {
 public:
  inline CMsgSteamNetworkingICESessionSummary() : CMsgSteamNetworkingICESessionSummary(nullptr) {}
  ~CMsgSteamNetworkingICESessionSummary() override;
  explicit PROTOBUF_CONSTEXPR CMsgSteamNetworkingICESessionSummary(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CMsgSteamNetworkingICESessionSummary(const CMsgSteamNetworkingICESessionSummary& from);
  CMsgSteamNetworkingICESessionSummary(CMsgSteamNetworkingICESessionSummary&& from) noexcept
    : CMsgSteamNetworkingICESessionSummary() {
    *this = ::std::move(from);
  }

  inline CMsgSteamNetworkingICESessionSummary& operator=(const CMsgSteamNetworkingICESessionSummary& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgSteamNetworkingICESessionSummary& operator=(CMsgSteamNetworkingICESessionSummary&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CMsgSteamNetworkingICESessionSummary& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgSteamNetworkingICESessionSummary* internal_default_instance() {
    return reinterpret_cast<const CMsgSteamNetworkingICESessionSummary*>(
               &_CMsgSteamNetworkingICESessionSummary_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    15;

  friend void swap(CMsgSteamNetworkingICESessionSummary& a, CMsgSteamNetworkingICESessionSummary& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgSteamNetworkingICESessionSummary* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CMsgSteamNetworkingICESessionSummary* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  CMsgSteamNetworkingICESessionSummary* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgSteamNetworkingICESessionSummary>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgSteamNetworkingICESessionSummary& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgSteamNetworkingICESessionSummary& from) {
    CMsgSteamNetworkingICESessionSummary::MergeImpl(*this, from);
  }
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CMsgSteamNetworkingICESessionSummary* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgSteamNetworkingICESessionSummary";
  }
  protected:
  explicit CMsgSteamNetworkingICESessionSummary(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kLocalCandidateTypesFieldNumber = 1,
    kRemoteCandidateTypesFieldNumber = 2,
    kInitialRouteKindFieldNumber = 3,
    kInitialPingFieldNumber = 4,
    kNegotiationMsFieldNumber = 5,
    kInitialScoreFieldNumber = 6,
    kFailureReasonCodeFieldNumber = 7,
    kSelectedSecondsFieldNumber = 12,
    kUserSettingsFieldNumber = 13,
    kIceEnableVarFieldNumber = 14,
    kLocalCandidateTypesAllowedFieldNumber = 15,
    kBestRouteKindFieldNumber = 16,
    kBestPingFieldNumber = 17,
    kBestScoreFieldNumber = 18,
    kBestTimeFieldNumber = 19,
  };
  // optional uint32 local_candidate_types = 1;
  bool has_local_candidate_types() const;
  private:
  bool _internal_has_local_candidate_types() const;
  public:
  void clear_local_candidate_types();
  uint32_t local_candidate_types() const;
  void set_local_candidate_types(uint32_t value);
  private:
  uint32_t _internal_local_candidate_types() const;
  void _internal_set_local_candidate_types(uint32_t value);
  public:

  // optional uint32 remote_candidate_types = 2;
  bool has_remote_candidate_types() const;
  private:
  bool _internal_has_remote_candidate_types() const;
  public:
  void clear_remote_candidate_types();
  uint32_t remote_candidate_types() const;
  void set_remote_candidate_types(uint32_t value);
  private:
  uint32_t _internal_remote_candidate_types() const;
  void _internal_set_remote_candidate_types(uint32_t value);
  public:

  // optional uint32 initial_route_kind = 3;
  bool has_initial_route_kind() const;
  private:
  bool _internal_has_initial_route_kind() const;
  public:
  void clear_initial_route_kind();
  uint32_t initial_route_kind() const;
  void set_initial_route_kind(uint32_t value);
  private:
  uint32_t _internal_initial_route_kind() const;
  void _internal_set_initial_route_kind(uint32_t value);
  public:

  // optional uint32 initial_ping = 4;
  bool has_initial_ping() const;
  private:
  bool _internal_has_initial_ping() const;
  public:
  void clear_initial_ping();
  uint32_t initial_ping() const;
  void set_initial_ping(uint32_t value);
  private:
  uint32_t _internal_initial_ping() const;
  void _internal_set_initial_ping(uint32_t value);
  public:

  // optional uint32 negotiation_ms = 5;
  bool has_negotiation_ms() const;
  private:
  bool _internal_has_negotiation_ms() const;
  public:
  void clear_negotiation_ms();
  uint32_t negotiation_ms() const;
  void set_negotiation_ms(uint32_t value);
  private:
  uint32_t _internal_negotiation_ms() const;
  void _internal_set_negotiation_ms(uint32_t value);
  public:

  // optional uint32 initial_score = 6;
  bool has_initial_score() const;
  private:
  bool _internal_has_initial_score() const;
  public:
  void clear_initial_score();
  uint32_t initial_score() const;
  void set_initial_score(uint32_t value);
  private:
  uint32_t _internal_initial_score() const;
  void _internal_set_initial_score(uint32_t value);
  public:

  // optional uint32 failure_reason_code = 7;
  bool has_failure_reason_code() const;
  private:
  bool _internal_has_failure_reason_code() const;
  public:
  void clear_failure_reason_code();
  uint32_t failure_reason_code() const;
  void set_failure_reason_code(uint32_t value);
  private:
  uint32_t _internal_failure_reason_code() const;
  void _internal_set_failure_reason_code(uint32_t value);
  public:

  // optional uint32 selected_seconds = 12;
  bool has_selected_seconds() const;
  private:
  bool _internal_has_selected_seconds() const;
  public:
  void clear_selected_seconds();
  uint32_t selected_seconds() const;
  void set_selected_seconds(uint32_t value);
  private:
  uint32_t _internal_selected_seconds() const;
  void _internal_set_selected_seconds(uint32_t value);
  public:

  // optional uint32 user_settings = 13;
  bool has_user_settings() const;
  private:
  bool _internal_has_user_settings() const;
  public:
  void clear_user_settings();
  uint32_t user_settings() const;
  void set_user_settings(uint32_t value);
  private:
  uint32_t _internal_user_settings() const;
  void _internal_set_user_settings(uint32_t value);
  public:

  // optional uint32 ice_enable_var = 14;
  bool has_ice_enable_var() const;
  private:
  bool _internal_has_ice_enable_var() const;
  public:
  void clear_ice_enable_var();
  uint32_t ice_enable_var() const;
  void set_ice_enable_var(uint32_t value);
  private:
  uint32_t _internal_ice_enable_var() const;
  void _internal_set_ice_enable_var(uint32_t value);
  public:

  // optional uint32 local_candidate_types_allowed = 15;
  bool has_local_candidate_types_allowed() const;
  private:
  bool _internal_has_local_candidate_types_allowed() const;
  public:
  void clear_local_candidate_types_allowed();
  uint32_t local_candidate_types_allowed() const;
  void set_local_candidate_types_allowed(uint32_t value);
  private:
  uint32_t _internal_local_candidate_types_allowed() const;
  void _internal_set_local_candidate_types_allowed(uint32_t value);
  public:

  // optional uint32 best_route_kind = 16;
  bool has_best_route_kind() const;
  private:
  bool _internal_has_best_route_kind() const;
  public:
  void clear_best_route_kind();
  uint32_t best_route_kind() const;
  void set_best_route_kind(uint32_t value);
  private:
  uint32_t _internal_best_route_kind() const;
  void _internal_set_best_route_kind(uint32_t value);
  public:

  // optional uint32 best_ping = 17;
  bool has_best_ping() const;
  private:
  bool _internal_has_best_ping() const;
  public:
  void clear_best_ping();
  uint32_t best_ping() const;
  void set_best_ping(uint32_t value);
  private:
  uint32_t _internal_best_ping() const;
  void _internal_set_best_ping(uint32_t value);
  public:

  // optional uint32 best_score = 18;
  bool has_best_score() const;
  private:
  bool _internal_has_best_score() const;
  public:
  void clear_best_score();
  uint32_t best_score() const;
  void set_best_score(uint32_t value);
  private:
  uint32_t _internal_best_score() const;
  void _internal_set_best_score(uint32_t value);
  public:

  // optional uint32 best_time = 19;
  bool has_best_time() const;
  private:
  bool _internal_has_best_time() const;
  public:
  void clear_best_time();
  uint32_t best_time() const;
  void set_best_time(uint32_t value);
  private:
  uint32_t _internal_best_time() const;
  void _internal_set_best_time(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgSteamNetworkingICESessionSummary)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  struct Impl_ {
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    uint32_t local_candidate_types_;
    uint32_t remote_candidate_types_;
    uint32_t initial_route_kind_;
    uint32_t initial_ping_;
    uint32_t negotiation_ms_;
    uint32_t initial_score_;
    uint32_t failure_reason_code_;
    uint32_t selected_seconds_;
    uint32_t user_settings_;
    uint32_t ice_enable_var_;
    uint32_t local_candidate_types_allowed_;
    uint32_t best_route_kind_;
    uint32_t best_ping_;
    uint32_t best_score_;
    uint32_t best_time_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_steamnetworkingsockets_5fmessages_2eproto;
};
// ===================================================================


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

#ifdef __GNUC__
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// CMsgSteamDatagramSessionCryptInfo

// optional .CMsgSteamDatagramSessionCryptInfo.EKeyType key_type = 1 [default = INVALID];
inline bool CMsgSteamDatagramSessionCryptInfo::_internal_has_key_type() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgSteamDatagramSessionCryptInfo::has_key_type() const {
  return _internal_has_key_type();
}
inline void CMsgSteamDatagramSessionCryptInfo::clear_key_type() {
  _impl_.key_type_ = 0;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline ::CMsgSteamDatagramSessionCryptInfo_EKeyType CMsgSteamDatagramSessionCryptInfo::_internal_key_type() const {
  return static_cast< ::CMsgSteamDatagramSessionCryptInfo_EKeyType >(_impl_.key_type_);
}
inline ::CMsgSteamDatagramSessionCryptInfo_EKeyType CMsgSteamDatagramSessionCryptInfo::key_type() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramSessionCryptInfo.key_type)
  return _internal_key_type();
}
inline void CMsgSteamDatagramSessionCryptInfo::_internal_set_key_type(::CMsgSteamDatagramSessionCryptInfo_EKeyType value) {
  assert(::CMsgSteamDatagramSessionCryptInfo_EKeyType_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.key_type_ = value;
}
inline void CMsgSteamDatagramSessionCryptInfo::set_key_type(::CMsgSteamDatagramSessionCryptInfo_EKeyType value) {
  _internal_set_key_type(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramSessionCryptInfo.key_type)
}

// optional bytes key_data = 2;
inline bool CMsgSteamDatagramSessionCryptInfo::_internal_has_key_data() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgSteamDatagramSessionCryptInfo::has_key_data() const {
  return _internal_has_key_data();
}
inline void CMsgSteamDatagramSessionCryptInfo::clear_key_data() {
  _impl_.key_data_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CMsgSteamDatagramSessionCryptInfo::key_data() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramSessionCryptInfo.key_data)
  return _internal_key_data();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgSteamDatagramSessionCryptInfo::set_key_data(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.key_data_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramSessionCryptInfo.key_data)
}
inline std::string* CMsgSteamDatagramSessionCryptInfo::mutable_key_data() {
  std::string* _s = _internal_mutable_key_data();
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramSessionCryptInfo.key_data)
  return _s;
}
inline const std::string& CMsgSteamDatagramSessionCryptInfo::_internal_key_data() const {
  return _impl_.key_data_.Get();
}
inline void CMsgSteamDatagramSessionCryptInfo::_internal_set_key_data(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.key_data_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramSessionCryptInfo::_internal_mutable_key_data() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.key_data_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramSessionCryptInfo::release_key_data() {
  // @@protoc_insertion_point(field_release:CMsgSteamDatagramSessionCryptInfo.key_data)
  if (!_internal_has_key_data()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.key_data_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.key_data_.IsDefault()) {
    _impl_.key_data_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgSteamDatagramSessionCryptInfo::set_allocated_key_data(std::string* key_data) {
  if (key_data != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.key_data_.SetAllocated(key_data, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.key_data_.IsDefault()) {
    _impl_.key_data_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamDatagramSessionCryptInfo.key_data)
}

// optional fixed64 nonce = 3;
inline bool CMsgSteamDatagramSessionCryptInfo::_internal_has_nonce() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CMsgSteamDatagramSessionCryptInfo::has_nonce() const {
  return _internal_has_nonce();
}
inline void CMsgSteamDatagramSessionCryptInfo::clear_nonce() {
  _impl_.nonce_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint64_t CMsgSteamDatagramSessionCryptInfo::_internal_nonce() const {
  return _impl_.nonce_;
}
inline uint64_t CMsgSteamDatagramSessionCryptInfo::nonce() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramSessionCryptInfo.nonce)
  return _internal_nonce();
}
inline void CMsgSteamDatagramSessionCryptInfo::_internal_set_nonce(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.nonce_ = value;
}
inline void CMsgSteamDatagramSessionCryptInfo::set_nonce(uint64_t value) {
  _internal_set_nonce(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramSessionCryptInfo.nonce)
}

// optional uint32 protocol_version = 4;
inline bool CMsgSteamDatagramSessionCryptInfo::_internal_has_protocol_version() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgSteamDatagramSessionCryptInfo::has_protocol_version() const {
  return _internal_has_protocol_version();
}
inline void CMsgSteamDatagramSessionCryptInfo::clear_protocol_version() {
  _impl_.protocol_version_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t CMsgSteamDatagramSessionCryptInfo::_internal_protocol_version() const {
  return _impl_.protocol_version_;
}
inline uint32_t CMsgSteamDatagramSessionCryptInfo::protocol_version() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramSessionCryptInfo.protocol_version)
  return _internal_protocol_version();
}
inline void CMsgSteamDatagramSessionCryptInfo::_internal_set_protocol_version(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.protocol_version_ = value;
}
inline void CMsgSteamDatagramSessionCryptInfo::set_protocol_version(uint32_t value) {
  _internal_set_protocol_version(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramSessionCryptInfo.protocol_version)
}

// repeated .ESteamNetworkingSocketsCipher ciphers = 5;
inline int CMsgSteamDatagramSessionCryptInfo::_internal_ciphers_size() const {
  return _impl_.ciphers_.size();
}
inline int CMsgSteamDatagramSessionCryptInfo::ciphers_size() const {
  return _internal_ciphers_size();
}
inline void CMsgSteamDatagramSessionCryptInfo::clear_ciphers() {
  _impl_.ciphers_.Clear();
}
inline ::ESteamNetworkingSocketsCipher CMsgSteamDatagramSessionCryptInfo::_internal_ciphers(int index) const {
  return static_cast< ::ESteamNetworkingSocketsCipher >(_impl_.ciphers_.Get(index));
}
inline ::ESteamNetworkingSocketsCipher CMsgSteamDatagramSessionCryptInfo::ciphers(int index) const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramSessionCryptInfo.ciphers)
  return _internal_ciphers(index);
}
inline void CMsgSteamDatagramSessionCryptInfo::set_ciphers(int index, ::ESteamNetworkingSocketsCipher value) {
  assert(::ESteamNetworkingSocketsCipher_IsValid(value));
  _impl_.ciphers_.Set(index, value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramSessionCryptInfo.ciphers)
}
inline void CMsgSteamDatagramSessionCryptInfo::_internal_add_ciphers(::ESteamNetworkingSocketsCipher value) {
  assert(::ESteamNetworkingSocketsCipher_IsValid(value));
  _impl_.ciphers_.Add(value);
}
inline void CMsgSteamDatagramSessionCryptInfo::add_ciphers(::ESteamNetworkingSocketsCipher value) {
  _internal_add_ciphers(value);
  // @@protoc_insertion_point(field_add:CMsgSteamDatagramSessionCryptInfo.ciphers)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>&
CMsgSteamDatagramSessionCryptInfo::ciphers() const {
  // @@protoc_insertion_point(field_list:CMsgSteamDatagramSessionCryptInfo.ciphers)
  return _impl_.ciphers_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
CMsgSteamDatagramSessionCryptInfo::_internal_mutable_ciphers() {
  return &_impl_.ciphers_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
CMsgSteamDatagramSessionCryptInfo::mutable_ciphers() {
  // @@protoc_insertion_point(field_mutable_list:CMsgSteamDatagramSessionCryptInfo.ciphers)
  return _internal_mutable_ciphers();
}

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

// CMsgSteamDatagramSessionCryptInfoSigned

// optional bytes info = 1;
inline bool CMsgSteamDatagramSessionCryptInfoSigned::_internal_has_info() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgSteamDatagramSessionCryptInfoSigned::has_info() const {
  return _internal_has_info();
}
inline void CMsgSteamDatagramSessionCryptInfoSigned::clear_info() {
  _impl_.info_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CMsgSteamDatagramSessionCryptInfoSigned::info() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramSessionCryptInfoSigned.info)
  return _internal_info();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgSteamDatagramSessionCryptInfoSigned::set_info(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.info_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramSessionCryptInfoSigned.info)
}
inline std::string* CMsgSteamDatagramSessionCryptInfoSigned::mutable_info() {
  std::string* _s = _internal_mutable_info();
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramSessionCryptInfoSigned.info)
  return _s;
}
inline const std::string& CMsgSteamDatagramSessionCryptInfoSigned::_internal_info() const {
  return _impl_.info_.Get();
}
inline void CMsgSteamDatagramSessionCryptInfoSigned::_internal_set_info(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.info_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramSessionCryptInfoSigned::_internal_mutable_info() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.info_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramSessionCryptInfoSigned::release_info() {
  // @@protoc_insertion_point(field_release:CMsgSteamDatagramSessionCryptInfoSigned.info)
  if (!_internal_has_info()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.info_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.info_.IsDefault()) {
    _impl_.info_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgSteamDatagramSessionCryptInfoSigned::set_allocated_info(std::string* info) {
  if (info != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.info_.SetAllocated(info, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.info_.IsDefault()) {
    _impl_.info_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamDatagramSessionCryptInfoSigned.info)
}

// optional bytes signature = 2;
inline bool CMsgSteamDatagramSessionCryptInfoSigned::_internal_has_signature() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgSteamDatagramSessionCryptInfoSigned::has_signature() const {
  return _internal_has_signature();
}
inline void CMsgSteamDatagramSessionCryptInfoSigned::clear_signature() {
  _impl_.signature_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& CMsgSteamDatagramSessionCryptInfoSigned::signature() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramSessionCryptInfoSigned.signature)
  return _internal_signature();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgSteamDatagramSessionCryptInfoSigned::set_signature(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.signature_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramSessionCryptInfoSigned.signature)
}
inline std::string* CMsgSteamDatagramSessionCryptInfoSigned::mutable_signature() {
  std::string* _s = _internal_mutable_signature();
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramSessionCryptInfoSigned.signature)
  return _s;
}
inline const std::string& CMsgSteamDatagramSessionCryptInfoSigned::_internal_signature() const {
  return _impl_.signature_.Get();
}
inline void CMsgSteamDatagramSessionCryptInfoSigned::_internal_set_signature(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.signature_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramSessionCryptInfoSigned::_internal_mutable_signature() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.signature_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramSessionCryptInfoSigned::release_signature() {
  // @@protoc_insertion_point(field_release:CMsgSteamDatagramSessionCryptInfoSigned.signature)
  if (!_internal_has_signature()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.signature_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.signature_.IsDefault()) {
    _impl_.signature_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgSteamDatagramSessionCryptInfoSigned::set_allocated_signature(std::string* signature) {
  if (signature != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.signature_.SetAllocated(signature, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.signature_.IsDefault()) {
    _impl_.signature_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamDatagramSessionCryptInfoSigned.signature)
}

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

// CMsgSteamDatagramDiagnostic

// optional uint32 severity = 1;
inline bool CMsgSteamDatagramDiagnostic::_internal_has_severity() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgSteamDatagramDiagnostic::has_severity() const {
  return _internal_has_severity();
}
inline void CMsgSteamDatagramDiagnostic::clear_severity() {
  _impl_.severity_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t CMsgSteamDatagramDiagnostic::_internal_severity() const {
  return _impl_.severity_;
}
inline uint32_t CMsgSteamDatagramDiagnostic::severity() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramDiagnostic.severity)
  return _internal_severity();
}
inline void CMsgSteamDatagramDiagnostic::_internal_set_severity(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.severity_ = value;
}
inline void CMsgSteamDatagramDiagnostic::set_severity(uint32_t value) {
  _internal_set_severity(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramDiagnostic.severity)
}

// optional string text = 2;
inline bool CMsgSteamDatagramDiagnostic::_internal_has_text() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgSteamDatagramDiagnostic::has_text() const {
  return _internal_has_text();
}
inline void CMsgSteamDatagramDiagnostic::clear_text() {
  _impl_.text_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CMsgSteamDatagramDiagnostic::text() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramDiagnostic.text)
  return _internal_text();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgSteamDatagramDiagnostic::set_text(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.text_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramDiagnostic.text)
}
inline std::string* CMsgSteamDatagramDiagnostic::mutable_text() {
  std::string* _s = _internal_mutable_text();
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramDiagnostic.text)
  return _s;
}
inline const std::string& CMsgSteamDatagramDiagnostic::_internal_text() const {
  return _impl_.text_.Get();
}
inline void CMsgSteamDatagramDiagnostic::_internal_set_text(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.text_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramDiagnostic::_internal_mutable_text() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.text_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramDiagnostic::release_text() {
  // @@protoc_insertion_point(field_release:CMsgSteamDatagramDiagnostic.text)
  if (!_internal_has_text()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.text_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.text_.IsDefault()) {
    _impl_.text_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgSteamDatagramDiagnostic::set_allocated_text(std::string* text) {
  if (text != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.text_.SetAllocated(text, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.text_.IsDefault()) {
    _impl_.text_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamDatagramDiagnostic.text)
}

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

// CMsgSteamDatagramLinkInstantaneousStats

// optional uint32 out_packets_per_sec_x10 = 1;
inline bool CMsgSteamDatagramLinkInstantaneousStats::_internal_has_out_packets_per_sec_x10() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgSteamDatagramLinkInstantaneousStats::has_out_packets_per_sec_x10() const {
  return _internal_has_out_packets_per_sec_x10();
}
inline void CMsgSteamDatagramLinkInstantaneousStats::clear_out_packets_per_sec_x10() {
  _impl_.out_packets_per_sec_x10_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t CMsgSteamDatagramLinkInstantaneousStats::_internal_out_packets_per_sec_x10() const {
  return _impl_.out_packets_per_sec_x10_;
}
inline uint32_t CMsgSteamDatagramLinkInstantaneousStats::out_packets_per_sec_x10() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramLinkInstantaneousStats.out_packets_per_sec_x10)
  return _internal_out_packets_per_sec_x10();
}
inline void CMsgSteamDatagramLinkInstantaneousStats::_internal_set_out_packets_per_sec_x10(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.out_packets_per_sec_x10_ = value;
}
inline void CMsgSteamDatagramLinkInstantaneousStats::set_out_packets_per_sec_x10(uint32_t value) {
  _internal_set_out_packets_per_sec_x10(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramLinkInstantaneousStats.out_packets_per_sec_x10)
}

// optional uint32 out_bytes_per_sec = 2;
inline bool CMsgSteamDatagramLinkInstantaneousStats::_internal_has_out_bytes_per_sec() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgSteamDatagramLinkInstantaneousStats::has_out_bytes_per_sec() const {
  return _internal_has_out_bytes_per_sec();
}
inline void CMsgSteamDatagramLinkInstantaneousStats::clear_out_bytes_per_sec() {
  _impl_.out_bytes_per_sec_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t CMsgSteamDatagramLinkInstantaneousStats::_internal_out_bytes_per_sec() const {
  return _impl_.out_bytes_per_sec_;
}
inline uint32_t CMsgSteamDatagramLinkInstantaneousStats::out_bytes_per_sec() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramLinkInstantaneousStats.out_bytes_per_sec)
  return _internal_out_bytes_per_sec();
}
inline void CMsgSteamDatagramLinkInstantaneousStats::_internal_set_out_bytes_per_sec(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.out_bytes_per_sec_ = value;
}
inline void CMsgSteamDatagramLinkInstantaneousStats::set_out_bytes_per_sec(uint32_t value) {
  _internal_set_out_bytes_per_sec(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramLinkInstantaneousStats.out_bytes_per_sec)
}

// optional uint32 in_packets_per_sec_x10 = 3;
inline bool CMsgSteamDatagramLinkInstantaneousStats::_internal_has_in_packets_per_sec_x10() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgSteamDatagramLinkInstantaneousStats::has_in_packets_per_sec_x10() const {
  return _internal_has_in_packets_per_sec_x10();
}
inline void CMsgSteamDatagramLinkInstantaneousStats::clear_in_packets_per_sec_x10() {
  _impl_.in_packets_per_sec_x10_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t CMsgSteamDatagramLinkInstantaneousStats::_internal_in_packets_per_sec_x10() const {
  return _impl_.in_packets_per_sec_x10_;
}
inline uint32_t CMsgSteamDatagramLinkInstantaneousStats::in_packets_per_sec_x10() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramLinkInstantaneousStats.in_packets_per_sec_x10)
  return _internal_in_packets_per_sec_x10();
}
inline void CMsgSteamDatagramLinkInstantaneousStats::_internal_set_in_packets_per_sec_x10(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.in_packets_per_sec_x10_ = value;
}
inline void CMsgSteamDatagramLinkInstantaneousStats::set_in_packets_per_sec_x10(uint32_t value) {
  _internal_set_in_packets_per_sec_x10(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramLinkInstantaneousStats.in_packets_per_sec_x10)
}

// optional uint32 in_bytes_per_sec = 4;
inline bool CMsgSteamDatagramLinkInstantaneousStats::_internal_has_in_bytes_per_sec() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CMsgSteamDatagramLinkInstantaneousStats::has_in_bytes_per_sec() const {
  return _internal_has_in_bytes_per_sec();
}
inline void CMsgSteamDatagramLinkInstantaneousStats::clear_in_bytes_per_sec() {
  _impl_.in_bytes_per_sec_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t CMsgSteamDatagramLinkInstantaneousStats::_internal_in_bytes_per_sec() const {
  return _impl_.in_bytes_per_sec_;
}
inline uint32_t CMsgSteamDatagramLinkInstantaneousStats::in_bytes_per_sec() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramLinkInstantaneousStats.in_bytes_per_sec)
  return _internal_in_bytes_per_sec();
}
inline void CMsgSteamDatagramLinkInstantaneousStats::_internal_set_in_bytes_per_sec(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.in_bytes_per_sec_ = value;
}
inline void CMsgSteamDatagramLinkInstantaneousStats::set_in_bytes_per_sec(uint32_t value) {
  _internal_set_in_bytes_per_sec(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramLinkInstantaneousStats.in_bytes_per_sec)
}

// optional uint32 ping_ms = 5;
inline bool CMsgSteamDatagramLinkInstantaneousStats::_internal_has_ping_ms() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CMsgSteamDatagramLinkInstantaneousStats::has_ping_ms() const {
  return _internal_has_ping_ms();
}
inline void CMsgSteamDatagramLinkInstantaneousStats::clear_ping_ms() {
  _impl_.ping_ms_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline uint32_t CMsgSteamDatagramLinkInstantaneousStats::_internal_ping_ms() const {
  return _impl_.ping_ms_;
}
inline uint32_t CMsgSteamDatagramLinkInstantaneousStats::ping_ms() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramLinkInstantaneousStats.ping_ms)
  return _internal_ping_ms();
}
inline void CMsgSteamDatagramLinkInstantaneousStats::_internal_set_ping_ms(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.ping_ms_ = value;
}
inline void CMsgSteamDatagramLinkInstantaneousStats::set_ping_ms(uint32_t value) {
  _internal_set_ping_ms(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramLinkInstantaneousStats.ping_ms)
}

// optional uint32 packets_dropped_pct = 6;
inline bool CMsgSteamDatagramLinkInstantaneousStats::_internal_has_packets_dropped_pct() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool CMsgSteamDatagramLinkInstantaneousStats::has_packets_dropped_pct() const {
  return _internal_has_packets_dropped_pct();
}
inline void CMsgSteamDatagramLinkInstantaneousStats::clear_packets_dropped_pct() {
  _impl_.packets_dropped_pct_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline uint32_t CMsgSteamDatagramLinkInstantaneousStats::_internal_packets_dropped_pct() const {
  return _impl_.packets_dropped_pct_;
}
inline uint32_t CMsgSteamDatagramLinkInstantaneousStats::packets_dropped_pct() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramLinkInstantaneousStats.packets_dropped_pct)
  return _internal_packets_dropped_pct();
}
inline void CMsgSteamDatagramLinkInstantaneousStats::_internal_set_packets_dropped_pct(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.packets_dropped_pct_ = value;
}
inline void CMsgSteamDatagramLinkInstantaneousStats::set_packets_dropped_pct(uint32_t value) {
  _internal_set_packets_dropped_pct(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramLinkInstantaneousStats.packets_dropped_pct)
}

// optional uint32 packets_weird_sequence_pct = 7;
inline bool CMsgSteamDatagramLinkInstantaneousStats::_internal_has_packets_weird_sequence_pct() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool CMsgSteamDatagramLinkInstantaneousStats::has_packets_weird_sequence_pct() const {
  return _internal_has_packets_weird_sequence_pct();
}
inline void CMsgSteamDatagramLinkInstantaneousStats::clear_packets_weird_sequence_pct() {
  _impl_.packets_weird_sequence_pct_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline uint32_t CMsgSteamDatagramLinkInstantaneousStats::_internal_packets_weird_sequence_pct() const {
  return _impl_.packets_weird_sequence_pct_;
}
inline uint32_t CMsgSteamDatagramLinkInstantaneousStats::packets_weird_sequence_pct() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramLinkInstantaneousStats.packets_weird_sequence_pct)
  return _internal_packets_weird_sequence_pct();
}
inline void CMsgSteamDatagramLinkInstantaneousStats::_internal_set_packets_weird_sequence_pct(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.packets_weird_sequence_pct_ = value;
}
inline void CMsgSteamDatagramLinkInstantaneousStats::set_packets_weird_sequence_pct(uint32_t value) {
  _internal_set_packets_weird_sequence_pct(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramLinkInstantaneousStats.packets_weird_sequence_pct)
}

// optional uint32 peak_jitter_usec = 8;
inline bool CMsgSteamDatagramLinkInstantaneousStats::_internal_has_peak_jitter_usec() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool CMsgSteamDatagramLinkInstantaneousStats::has_peak_jitter_usec() const {
  return _internal_has_peak_jitter_usec();
}
inline void CMsgSteamDatagramLinkInstantaneousStats::clear_peak_jitter_usec() {
  _impl_.peak_jitter_usec_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline uint32_t CMsgSteamDatagramLinkInstantaneousStats::_internal_peak_jitter_usec() const {
  return _impl_.peak_jitter_usec_;
}
inline uint32_t CMsgSteamDatagramLinkInstantaneousStats::peak_jitter_usec() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramLinkInstantaneousStats.peak_jitter_usec)
  return _internal_peak_jitter_usec();
}
inline void CMsgSteamDatagramLinkInstantaneousStats::_internal_set_peak_jitter_usec(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.peak_jitter_usec_ = value;
}
inline void CMsgSteamDatagramLinkInstantaneousStats::set_peak_jitter_usec(uint32_t value) {
  _internal_set_peak_jitter_usec(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramLinkInstantaneousStats.peak_jitter_usec)
}

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

// CMsgSteamDatagramLinkLifetimeStats

// optional uint32 connected_seconds = 2;
inline bool CMsgSteamDatagramLinkLifetimeStats::_internal_has_connected_seconds() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool CMsgSteamDatagramLinkLifetimeStats::has_connected_seconds() const {
  return _internal_has_connected_seconds();
}
inline void CMsgSteamDatagramLinkLifetimeStats::clear_connected_seconds() {
  _impl_.connected_seconds_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline uint32_t CMsgSteamDatagramLinkLifetimeStats::_internal_connected_seconds() const {
  return _impl_.connected_seconds_;
}
inline uint32_t CMsgSteamDatagramLinkLifetimeStats::connected_seconds() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramLinkLifetimeStats.connected_seconds)
  return _internal_connected_seconds();
}
inline void CMsgSteamDatagramLinkLifetimeStats::_internal_set_connected_seconds(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.connected_seconds_ = value;
}
inline void CMsgSteamDatagramLinkLifetimeStats::set_connected_seconds(uint32_t value) {
  _internal_set_connected_seconds(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramLinkLifetimeStats.connected_seconds)
}

// optional uint64 packets_sent = 3;
inline bool CMsgSteamDatagramLinkLifetimeStats::_internal_has_packets_sent() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgSteamDatagramLinkLifetimeStats::has_packets_sent() const {
  return _internal_has_packets_sent();
}
inline void CMsgSteamDatagramLinkLifetimeStats::clear_packets_sent() {
  _impl_.packets_sent_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint64_t CMsgSteamDatagramLinkLifetimeStats::_internal_packets_sent() const {
  return _impl_.packets_sent_;
}
inline uint64_t CMsgSteamDatagramLinkLifetimeStats::packets_sent() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramLinkLifetimeStats.packets_sent)
  return _internal_packets_sent();
}
inline void CMsgSteamDatagramLinkLifetimeStats::_internal_set_packets_sent(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.packets_sent_ = value;
}
inline void CMsgSteamDatagramLinkLifetimeStats::set_packets_sent(uint64_t value) {
  _internal_set_packets_sent(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramLinkLifetimeStats.packets_sent)
}

// optional uint64 kb_sent = 4;
inline bool CMsgSteamDatagramLinkLifetimeStats::_internal_has_kb_sent() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgSteamDatagramLinkLifetimeStats::has_kb_sent() const {
  return _internal_has_kb_sent();
}
inline void CMsgSteamDatagramLinkLifetimeStats::clear_kb_sent() {
  _impl_.kb_sent_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint64_t CMsgSteamDatagramLinkLifetimeStats::_internal_kb_sent() const {
  return _impl_.kb_sent_;
}
inline uint64_t CMsgSteamDatagramLinkLifetimeStats::kb_sent() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramLinkLifetimeStats.kb_sent)
  return _internal_kb_sent();
}
inline void CMsgSteamDatagramLinkLifetimeStats::_internal_set_kb_sent(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.kb_sent_ = value;
}
inline void CMsgSteamDatagramLinkLifetimeStats::set_kb_sent(uint64_t value) {
  _internal_set_kb_sent(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramLinkLifetimeStats.kb_sent)
}

// optional uint64 packets_recv = 5;
inline bool CMsgSteamDatagramLinkLifetimeStats::_internal_has_packets_recv() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgSteamDatagramLinkLifetimeStats::has_packets_recv() const {
  return _internal_has_packets_recv();
}
inline void CMsgSteamDatagramLinkLifetimeStats::clear_packets_recv() {
  _impl_.packets_recv_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint64_t CMsgSteamDatagramLinkLifetimeStats::_internal_packets_recv() const {
  return _impl_.packets_recv_;
}
inline uint64_t CMsgSteamDatagramLinkLifetimeStats::packets_recv() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramLinkLifetimeStats.packets_recv)
  return _internal_packets_recv();
}
inline void CMsgSteamDatagramLinkLifetimeStats::_internal_set_packets_recv(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.packets_recv_ = value;
}
inline void CMsgSteamDatagramLinkLifetimeStats::set_packets_recv(uint64_t value) {
  _internal_set_packets_recv(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramLinkLifetimeStats.packets_recv)
}

// optional uint64 kb_recv = 6;
inline bool CMsgSteamDatagramLinkLifetimeStats::_internal_has_kb_recv() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CMsgSteamDatagramLinkLifetimeStats::has_kb_recv() const {
  return _internal_has_kb_recv();
}
inline void CMsgSteamDatagramLinkLifetimeStats::clear_kb_recv() {
  _impl_.kb_recv_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint64_t CMsgSteamDatagramLinkLifetimeStats::_internal_kb_recv() const {
  return _impl_.kb_recv_;
}
inline uint64_t CMsgSteamDatagramLinkLifetimeStats::kb_recv() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramLinkLifetimeStats.kb_recv)
  return _internal_kb_recv();
}
inline void CMsgSteamDatagramLinkLifetimeStats::_internal_set_kb_recv(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.kb_recv_ = value;
}
inline void CMsgSteamDatagramLinkLifetimeStats::set_kb_recv(uint64_t value) {
  _internal_set_kb_recv(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramLinkLifetimeStats.kb_recv)
}

// optional uint64 packets_recv_sequenced = 7;
inline bool CMsgSteamDatagramLinkLifetimeStats::_internal_has_packets_recv_sequenced() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CMsgSteamDatagramLinkLifetimeStats::has_packets_recv_sequenced() const {
  return _internal_has_packets_recv_sequenced();
}
inline void CMsgSteamDatagramLinkLifetimeStats::clear_packets_recv_sequenced() {
  _impl_.packets_recv_sequenced_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline uint64_t CMsgSteamDatagramLinkLifetimeStats::_internal_packets_recv_sequenced() const {
  return _impl_.packets_recv_sequenced_;
}
inline uint64_t CMsgSteamDatagramLinkLifetimeStats::packets_recv_sequenced() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramLinkLifetimeStats.packets_recv_sequenced)
  return _internal_packets_recv_sequenced();
}
inline void CMsgSteamDatagramLinkLifetimeStats::_internal_set_packets_recv_sequenced(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.packets_recv_sequenced_ = value;
}
inline void CMsgSteamDatagramLinkLifetimeStats::set_packets_recv_sequenced(uint64_t value) {
  _internal_set_packets_recv_sequenced(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramLinkLifetimeStats.packets_recv_sequenced)
}

// optional uint64 packets_recv_dropped = 8;
inline bool CMsgSteamDatagramLinkLifetimeStats::_internal_has_packets_recv_dropped() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool CMsgSteamDatagramLinkLifetimeStats::has_packets_recv_dropped() const {
  return _internal_has_packets_recv_dropped();
}
inline void CMsgSteamDatagramLinkLifetimeStats::clear_packets_recv_dropped() {
  _impl_.packets_recv_dropped_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline uint64_t CMsgSteamDatagramLinkLifetimeStats::_internal_packets_recv_dropped() const {
  return _impl_.packets_recv_dropped_;
}
inline uint64_t CMsgSteamDatagramLinkLifetimeStats::packets_recv_dropped() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramLinkLifetimeStats.packets_recv_dropped)
  return _internal_packets_recv_dropped();
}
inline void CMsgSteamDatagramLinkLifetimeStats::_internal_set_packets_recv_dropped(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.packets_recv_dropped_ = value;
}
inline void CMsgSteamDatagramLinkLifetimeStats::set_packets_recv_dropped(uint64_t value) {
  _internal_set_packets_recv_dropped(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramLinkLifetimeStats.packets_recv_dropped)
}

// optional uint64 packets_recv_out_of_order = 9;
inline bool CMsgSteamDatagramLinkLifetimeStats::_internal_has_packets_recv_out_of_order() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool CMsgSteamDatagramLinkLifetimeStats::has_packets_recv_out_of_order() const {
  return _internal_has_packets_recv_out_of_order();
}
inline void CMsgSteamDatagramLinkLifetimeStats::clear_packets_recv_out_of_order() {
  _impl_.packets_recv_out_of_order_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline uint64_t CMsgSteamDatagramLinkLifetimeStats::_internal_packets_recv_out_of_order() const {
  return _impl_.packets_recv_out_of_order_;
}
inline uint64_t CMsgSteamDatagramLinkLifetimeStats::packets_recv_out_of_order() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramLinkLifetimeStats.packets_recv_out_of_order)
  return _internal_packets_recv_out_of_order();
}
inline void CMsgSteamDatagramLinkLifetimeStats::_internal_set_packets_recv_out_of_order(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.packets_recv_out_of_order_ = value;
}
inline void CMsgSteamDatagramLinkLifetimeStats::set_packets_recv_out_of_order(uint64_t value) {
  _internal_set_packets_recv_out_of_order(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramLinkLifetimeStats.packets_recv_out_of_order)
}

// optional uint64 packets_recv_out_of_order_corrected = 15;
inline bool CMsgSteamDatagramLinkLifetimeStats::_internal_has_packets_recv_out_of_order_corrected() const {
  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
  return value;
}
inline bool CMsgSteamDatagramLinkLifetimeStats::has_packets_recv_out_of_order_corrected() const {
  return _internal_has_packets_recv_out_of_order_corrected();
}
inline void CMsgSteamDatagramLinkLifetimeStats::clear_packets_recv_out_of_order_corrected() {
  _impl_.packets_recv_out_of_order_corrected_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000800u;
}
inline uint64_t CMsgSteamDatagramLinkLifetimeStats::_internal_packets_recv_out_of_order_corrected() const {
  return _impl_.packets_recv_out_of_order_corrected_;
}
inline uint64_t CMsgSteamDatagramLinkLifetimeStats::packets_recv_out_of_order_corrected() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramLinkLifetimeStats.packets_recv_out_of_order_corrected)
  return _internal_packets_recv_out_of_order_corrected();
}
inline void CMsgSteamDatagramLinkLifetimeStats::_internal_set_packets_recv_out_of_order_corrected(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000800u;
  _impl_.packets_recv_out_of_order_corrected_ = value;
}
inline void CMsgSteamDatagramLinkLifetimeStats::set_packets_recv_out_of_order_corrected(uint64_t value) {
  _internal_set_packets_recv_out_of_order_corrected(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramLinkLifetimeStats.packets_recv_out_of_order_corrected)
}

// optional uint64 packets_recv_duplicate = 10;
inline bool CMsgSteamDatagramLinkLifetimeStats::_internal_has_packets_recv_duplicate() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool CMsgSteamDatagramLinkLifetimeStats::has_packets_recv_duplicate() const {
  return _internal_has_packets_recv_duplicate();
}
inline void CMsgSteamDatagramLinkLifetimeStats::clear_packets_recv_duplicate() {
  _impl_.packets_recv_duplicate_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline uint64_t CMsgSteamDatagramLinkLifetimeStats::_internal_packets_recv_duplicate() const {
  return _impl_.packets_recv_duplicate_;
}
inline uint64_t CMsgSteamDatagramLinkLifetimeStats::packets_recv_duplicate() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramLinkLifetimeStats.packets_recv_duplicate)
  return _internal_packets_recv_duplicate();
}
inline void CMsgSteamDatagramLinkLifetimeStats::_internal_set_packets_recv_duplicate(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.packets_recv_duplicate_ = value;
}
inline void CMsgSteamDatagramLinkLifetimeStats::set_packets_recv_duplicate(uint64_t value) {
  _internal_set_packets_recv_duplicate(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramLinkLifetimeStats.packets_recv_duplicate)
}

// optional uint64 packets_recv_lurch = 11;
inline bool CMsgSteamDatagramLinkLifetimeStats::_internal_has_packets_recv_lurch() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool CMsgSteamDatagramLinkLifetimeStats::has_packets_recv_lurch() const {
  return _internal_has_packets_recv_lurch();
}
inline void CMsgSteamDatagramLinkLifetimeStats::clear_packets_recv_lurch() {
  _impl_.packets_recv_lurch_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline uint64_t CMsgSteamDatagramLinkLifetimeStats::_internal_packets_recv_lurch() const {
  return _impl_.packets_recv_lurch_;
}
inline uint64_t CMsgSteamDatagramLinkLifetimeStats::packets_recv_lurch() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramLinkLifetimeStats.packets_recv_lurch)
  return _internal_packets_recv_lurch();
}
inline void CMsgSteamDatagramLinkLifetimeStats::_internal_set_packets_recv_lurch(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000400u;
  _impl_.packets_recv_lurch_ = value;
}
inline void CMsgSteamDatagramLinkLifetimeStats::set_packets_recv_lurch(uint64_t value) {
  _internal_set_packets_recv_lurch(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramLinkLifetimeStats.packets_recv_lurch)
}

// repeated uint64 multipath_packets_recv_sequenced = 12;
inline int CMsgSteamDatagramLinkLifetimeStats::_internal_multipath_packets_recv_sequenced_size() const {
  return _impl_.multipath_packets_recv_sequenced_.size();
}
inline int CMsgSteamDatagramLinkLifetimeStats::multipath_packets_recv_sequenced_size() const {
  return _internal_multipath_packets_recv_sequenced_size();
}
inline void CMsgSteamDatagramLinkLifetimeStats::clear_multipath_packets_recv_sequenced() {
  _impl_.multipath_packets_recv_sequenced_.Clear();
}
inline uint64_t CMsgSteamDatagramLinkLifetimeStats::_internal_multipath_packets_recv_sequenced(int index) const {
  return _impl_.multipath_packets_recv_sequenced_.Get(index);
}
inline uint64_t CMsgSteamDatagramLinkLifetimeStats::multipath_packets_recv_sequenced(int index) const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramLinkLifetimeStats.multipath_packets_recv_sequenced)
  return _internal_multipath_packets_recv_sequenced(index);
}
inline void CMsgSteamDatagramLinkLifetimeStats::set_multipath_packets_recv_sequenced(int index, uint64_t value) {
  _impl_.multipath_packets_recv_sequenced_.Set(index, value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramLinkLifetimeStats.multipath_packets_recv_sequenced)
}
inline void CMsgSteamDatagramLinkLifetimeStats::_internal_add_multipath_packets_recv_sequenced(uint64_t value) {
  _impl_.multipath_packets_recv_sequenced_.Add(value);
}
inline void CMsgSteamDatagramLinkLifetimeStats::add_multipath_packets_recv_sequenced(uint64_t value) {
  _internal_add_multipath_packets_recv_sequenced(value);
  // @@protoc_insertion_point(field_add:CMsgSteamDatagramLinkLifetimeStats.multipath_packets_recv_sequenced)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
CMsgSteamDatagramLinkLifetimeStats::_internal_multipath_packets_recv_sequenced() const {
  return _impl_.multipath_packets_recv_sequenced_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
CMsgSteamDatagramLinkLifetimeStats::multipath_packets_recv_sequenced() const {
  // @@protoc_insertion_point(field_list:CMsgSteamDatagramLinkLifetimeStats.multipath_packets_recv_sequenced)
  return _internal_multipath_packets_recv_sequenced();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
CMsgSteamDatagramLinkLifetimeStats::_internal_mutable_multipath_packets_recv_sequenced() {
  return &_impl_.multipath_packets_recv_sequenced_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
CMsgSteamDatagramLinkLifetimeStats::mutable_multipath_packets_recv_sequenced() {
  // @@protoc_insertion_point(field_mutable_list:CMsgSteamDatagramLinkLifetimeStats.multipath_packets_recv_sequenced)
  return _internal_mutable_multipath_packets_recv_sequenced();
}

// repeated uint64 multipath_packets_recv_later = 13;
inline int CMsgSteamDatagramLinkLifetimeStats::_internal_multipath_packets_recv_later_size() const {
  return _impl_.multipath_packets_recv_later_.size();
}
inline int CMsgSteamDatagramLinkLifetimeStats::multipath_packets_recv_later_size() const {
  return _internal_multipath_packets_recv_later_size();
}
inline void CMsgSteamDatagramLinkLifetimeStats::clear_multipath_packets_recv_later() {
  _impl_.multipath_packets_recv_later_.Clear();
}
inline uint64_t CMsgSteamDatagramLinkLifetimeStats::_internal_multipath_packets_recv_later(int index) const {
  return _impl_.multipath_packets_recv_later_.Get(index);
}
inline uint64_t CMsgSteamDatagramLinkLifetimeStats::multipath_packets_recv_later(int index) const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramLinkLifetimeStats.multipath_packets_recv_later)
  return _internal_multipath_packets_recv_later(index);
}
inline void CMsgSteamDatagramLinkLifetimeStats::set_multipath_packets_recv_later(int index, uint64_t value) {
  _impl_.multipath_packets_recv_later_.Set(index, value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramLinkLifetimeStats.multipath_packets_recv_later)
}
inline void CMsgSteamDatagramLinkLifetimeStats::_internal_add_multipath_packets_recv_later(uint64_t value) {
  _impl_.multipath_packets_recv_later_.Add(value);
}
inline void CMsgSteamDatagramLinkLifetimeStats::add_multipath_packets_recv_later(uint64_t value) {
  _internal_add_multipath_packets_recv_later(value);
  // @@protoc_insertion_point(field_add:CMsgSteamDatagramLinkLifetimeStats.multipath_packets_recv_later)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
CMsgSteamDatagramLinkLifetimeStats::_internal_multipath_packets_recv_later() const {
  return _impl_.multipath_packets_recv_later_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
CMsgSteamDatagramLinkLifetimeStats::multipath_packets_recv_later() const {
  // @@protoc_insertion_point(field_list:CMsgSteamDatagramLinkLifetimeStats.multipath_packets_recv_later)
  return _internal_multipath_packets_recv_later();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
CMsgSteamDatagramLinkLifetimeStats::_internal_mutable_multipath_packets_recv_later() {
  return &_impl_.multipath_packets_recv_later_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
CMsgSteamDatagramLinkLifetimeStats::mutable_multipath_packets_recv_later() {
  // @@protoc_insertion_point(field_mutable_list:CMsgSteamDatagramLinkLifetimeStats.multipath_packets_recv_later)
  return _internal_mutable_multipath_packets_recv_later();
}

// optional uint32 multipath_send_enabled = 14;
inline bool CMsgSteamDatagramLinkLifetimeStats::_internal_has_multipath_send_enabled() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool CMsgSteamDatagramLinkLifetimeStats::has_multipath_send_enabled() const {
  return _internal_has_multipath_send_enabled();
}
inline void CMsgSteamDatagramLinkLifetimeStats::clear_multipath_send_enabled() {
  _impl_.multipath_send_enabled_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline uint32_t CMsgSteamDatagramLinkLifetimeStats::_internal_multipath_send_enabled() const {
  return _impl_.multipath_send_enabled_;
}
inline uint32_t CMsgSteamDatagramLinkLifetimeStats::multipath_send_enabled() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramLinkLifetimeStats.multipath_send_enabled)
  return _internal_multipath_send_enabled();
}
inline void CMsgSteamDatagramLinkLifetimeStats::_internal_set_multipath_send_enabled(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.multipath_send_enabled_ = value;
}
inline void CMsgSteamDatagramLinkLifetimeStats::set_multipath_send_enabled(uint32_t value) {
  _internal_set_multipath_send_enabled(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramLinkLifetimeStats.multipath_send_enabled)
}

// optional uint32 quality_histogram_100 = 21;
inline bool CMsgSteamDatagramLinkLifetimeStats::_internal_has_quality_histogram_100() const {
  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
  return value;
}
inline bool CMsgSteamDatagramLinkLifetimeStats::has_quality_histogram_100() const {
  return _internal_has_quality_histogram_100();
}
inline void CMsgSteamDatagramLinkLifetimeStats::clear_quality_histogram_100() {
  _impl_.quality_histogram_100_ = 0u;
  _impl_._has_bits_[0] &= ~0x00001000u;
}
inline uint32_t CMsgSteamDatagramLinkLifetimeStats::_internal_quality_histogram_100() const {
  return _impl_.quality_histogram_100_;
}
inline uint32_t CMsgSteamDatagramLinkLifetimeStats::quality_histogram_100() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramLinkLifetimeStats.quality_histogram_100)
  return _internal_quality_histogram_100();
}
inline void CMsgSteamDatagramLinkLifetimeStats::_internal_set_quality_histogram_100(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00001000u;
  _impl_.quality_histogram_100_ = value;
}
inline void CMsgSteamDatagramLinkLifetimeStats::set_quality_histogram_100(uint32_t value) {
  _internal_set_quality_histogram_100(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramLinkLifetimeStats.quality_histogram_100)
}

// optional uint32 quality_histogram_99 = 22;
inline bool CMsgSteamDatagramLinkLifetimeStats::_internal_has_quality_histogram_99() const {
  bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0;
  return value;
}
inline bool CMsgSteamDatagramLinkLifetimeStats::has_quality_histogram_99() const {
  return _internal_has_quality_histogram_99();
}
inline void CMsgSteamDatagramLinkLifetimeStats::clear_quality_histogram_99() {
  _impl_.quality_histogram_99_ = 0u;
  _impl_._has_bits_[0] &= ~0x00002000u;
}
inline uint32_t CMsgSteamDatagramLinkLifetimeStats::_internal_quality_histogram_99() const {
  return _impl_.quality_histogram_99_;
}
inline uint32_t CMsgSteamDatagramLinkLifetimeStats::quality_histogram_99() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramLinkLifetimeStats.quality_histogram_99)
  return _internal_quality_histogram_99();
}
inline void CMsgSteamDatagramLinkLifetimeStats::_internal_set_quality_histogram_99(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00002000u;
  _impl_.quality_histogram_99_ = value;
}
inline void CMsgSteamDatagramLinkLifetimeStats::set_quality_histogram_99(uint32_t value) {
  _internal_set_quality_histogram_99(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramLinkLifetimeStats.quality_histogram_99)
}

// optional uint32 quality_histogram_97 = 23;
inline bool CMsgSteamDatagramLinkLifetimeStats::_internal_has_quality_histogram_97() const {
  bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0;
  return value;
}
inline bool CMsgSteamDatagramLinkLifetimeStats::has_quality_histogram_97() const {
  return _internal_has_quality_histogram_97();
}
inline void CMsgSteamDatagramLinkLifetimeStats::clear_quality_histogram_97() {
  _impl_.quality_histogram_97_ = 0u;
  _impl_._has_bits_[0] &= ~0x00004000u;
}
inline uint32_t CMsgSteamDatagramLinkLifetimeStats::_internal_quality_histogram_97() const {
  return _impl_.quality_histogram_97_;
}
inline uint32_t CMsgSteamDatagramLinkLifetimeStats::quality_histogram_97() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramLinkLifetimeStats.quality_histogram_97)
  return _internal_quality_histogram_97();
}
inline void CMsgSteamDatagramLinkLifetimeStats::_internal_set_quality_histogram_97(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00004000u;
  _impl_.quality_histogram_97_ = value;
}
inline void CMsgSteamDatagramLinkLifetimeStats::set_quality_histogram_97(uint32_t value) {
  _internal_set_quality_histogram_97(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramLinkLifetimeStats.quality_histogram_97)
}

// optional uint32 quality_histogram_95 = 24;
inline bool CMsgSteamDatagramLinkLifetimeStats::_internal_has_quality_histogram_95() const {
  bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0;
  return value;
}
inline bool CMsgSteamDatagramLinkLifetimeStats::has_quality_histogram_95() const {
  return _internal_has_quality_histogram_95();
}
inline void CMsgSteamDatagramLinkLifetimeStats::clear_quality_histogram_95() {
  _impl_.quality_histogram_95_ = 0u;
  _impl_._has_bits_[0] &= ~0x00008000u;
}
inline uint32_t CMsgSteamDatagramLinkLifetimeStats::_internal_quality_histogram_95() const {
  return _impl_.quality_histogram_95_;
}
inline uint32_t CMsgSteamDatagramLinkLifetimeStats::quality_histogram_95() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramLinkLifetimeStats.quality_histogram_95)
  return _internal_quality_histogram_95();
}
inline void CMsgSteamDatagramLinkLifetimeStats::_internal_set_quality_histogram_95(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00008000u;
  _impl_.quality_histogram_95_ = value;
}
inline void CMsgSteamDatagramLinkLifetimeStats::set_quality_histogram_95(uint32_t value) {
  _internal_set_quality_histogram_95(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramLinkLifetimeStats.quality_histogram_95)
}

// optional uint32 quality_histogram_90 = 25;
inline bool CMsgSteamDatagramLinkLifetimeStats::_internal_has_quality_histogram_90() const {
  bool value = (_impl_._has_bits_[0] & 0x00010000u) != 0;
  return value;
}
inline bool CMsgSteamDatagramLinkLifetimeStats::has_quality_histogram_90() const {
  return _internal_has_quality_histogram_90();
}
inline void CMsgSteamDatagramLinkLifetimeStats::clear_quality_histogram_90() {
  _impl_.quality_histogram_90_ = 0u;
  _impl_._has_bits_[0] &= ~0x00010000u;
}
inline uint32_t CMsgSteamDatagramLinkLifetimeStats::_internal_quality_histogram_90() const {
  return _impl_.quality_histogram_90_;
}
inline uint32_t CMsgSteamDatagramLinkLifetimeStats::quality_histogram_90() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramLinkLifetimeStats.quality_histogram_90)
  return _internal_quality_histogram_90();
}
inline void CMsgSteamDatagramLinkLifetimeStats::_internal_set_quality_histogram_90(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00010000u;
  _impl_.quality_histogram_90_ = value;
}
inline void CMsgSteamDatagramLinkLifetimeStats::set_quality_histogram_90(uint32_t value) {
  _internal_set_quality_histogram_90(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramLinkLifetimeStats.quality_histogram_90)
}

// optional uint32 quality_histogram_75 = 26;
inline bool CMsgSteamDatagramLinkLifetimeStats::_internal_has_quality_histogram_75() const {
  bool value = (_impl_._has_bits_[0] & 0x00020000u) != 0;
  return value;
}
inline bool CMsgSteamDatagramLinkLifetimeStats::has_quality_histogram_75() const {
  return _internal_has_quality_histogram_75();
}
inline void CMsgSteamDatagramLinkLifetimeStats::clear_quality_histogram_75() {
  _impl_.quality_histogram_75_ = 0u;
  _impl_._has_bits_[0] &= ~0x00020000u;
}
inline uint32_t CMsgSteamDatagramLinkLifetimeStats::_internal_quality_histogram_75() const {
  return _impl_.quality_histogram_75_;
}
inline uint32_t CMsgSteamDatagramLinkLifetimeStats::quality_histogram_75() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramLinkLifetimeStats.quality_histogram_75)
  return _internal_quality_histogram_75();
}
inline void CMsgSteamDatagramLinkLifetimeStats::_internal_set_quality_histogram_75(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00020000u;
  _impl_.quality_histogram_75_ = value;
}
inline void CMsgSteamDatagramLinkLifetimeStats::set_quality_histogram_75(uint32_t value) {
  _internal_set_quality_histogram_75(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramLinkLifetimeStats.quality_histogram_75)
}

// optional uint32 quality_histogram_50 = 27;
inline bool CMsgSteamDatagramLinkLifetimeStats::_internal_has_quality_histogram_50() const {
  bool value = (_impl_._has_bits_[0] & 0x00040000u) != 0;
  return value;
}
inline bool CMsgSteamDatagramLinkLifetimeStats::has_quality_histogram_50() const {
  return _internal_has_quality_histogram_50();
}
inline void CMsgSteamDatagramLinkLifetimeStats::clear_quality_histogram_50() {
  _impl_.quality_histogram_50_ = 0u;
  _impl_._has_bits_[0] &= ~0x00040000u;
}
inline uint32_t CMsgSteamDatagramLinkLifetimeStats::_internal_quality_histogram_50() const {
  return _impl_.quality_histogram_50_;
}
inline uint32_t CMsgSteamDatagramLinkLifetimeStats::quality_histogram_50() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramLinkLifetimeStats.quality_histogram_50)
  return _internal_quality_histogram_50();
}
inline void CMsgSteamDatagramLinkLifetimeStats::_internal_set_quality_histogram_50(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00040000u;
  _impl_.quality_histogram_50_ = value;
}
inline void CMsgSteamDatagramLinkLifetimeStats::set_quality_histogram_50(uint32_t value) {
  _internal_set_quality_histogram_50(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramLinkLifetimeStats.quality_histogram_50)
}

// optional uint32 quality_histogram_1 = 28;
inline bool CMsgSteamDatagramLinkLifetimeStats::_internal_has_quality_histogram_1() const {
  bool value = (_impl_._has_bits_[0] & 0x00080000u) != 0;
  return value;
}
inline bool CMsgSteamDatagramLinkLifetimeStats::has_quality_histogram_1() const {
  return _internal_has_quality_histogram_1();
}
inline void CMsgSteamDatagramLinkLifetimeStats::clear_quality_histogram_1() {
  _impl_.quality_histogram_1_ = 0u;
  _impl_._has_bits_[0] &= ~0x00080000u;
}
inline uint32_t CMsgSteamDatagramLinkLifetimeStats::_internal_quality_histogram_1() const {
  return _impl_.quality_histogram_1_;
}
inline uint32_t CMsgSteamDatagramLinkLifetimeStats::quality_histogram_1() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramLinkLifetimeStats.quality_histogram_1)
  return _internal_quality_histogram_1();
}
inline void CMsgSteamDatagramLinkLifetimeStats::_internal_set_quality_histogram_1(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00080000u;
  _impl_.quality_histogram_1_ = value;
}
inline void CMsgSteamDatagramLinkLifetimeStats::set_quality_histogram_1(uint32_t value) {
  _internal_set_quality_histogram_1(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramLinkLifetimeStats.quality_histogram_1)
}

// optional uint32 quality_histogram_dead = 29;
inline bool CMsgSteamDatagramLinkLifetimeStats::_internal_has_quality_histogram_dead() const {
  bool value = (_impl_._has_bits_[0] & 0x00100000u) != 0;
  return value;
}
inline bool CMsgSteamDatagramLinkLifetimeStats::has_quality_histogram_dead() const {
  return _internal_has_quality_histogram_dead();
}
inline void CMsgSteamDatagramLinkLifetimeStats::clear_quality_histogram_dead() {
  _impl_.quality_histogram_dead_ = 0u;
  _impl_._has_bits_[0] &= ~0x00100000u;
}
inline uint32_t CMsgSteamDatagramLinkLifetimeStats::_internal_quality_histogram_dead() const {
  return _impl_.quality_histogram_dead_;
}
inline uint32_t CMsgSteamDatagramLinkLifetimeStats::quality_histogram_dead() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramLinkLifetimeStats.quality_histogram_dead)
  return _internal_quality_histogram_dead();
}
inline void CMsgSteamDatagramLinkLifetimeStats::_internal_set_quality_histogram_dead(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00100000u;
  _impl_.quality_histogram_dead_ = value;
}
inline void CMsgSteamDatagramLinkLifetimeStats::set_quality_histogram_dead(uint32_t value) {
  _internal_set_quality_histogram_dead(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramLinkLifetimeStats.quality_histogram_dead)
}

// optional uint32 quality_ntile_2nd = 30;
inline bool CMsgSteamDatagramLinkLifetimeStats::_internal_has_quality_ntile_2nd() const {
  bool value = (_impl_._has_bits_[0] & 0x00200000u) != 0;
  return value;
}
inline bool CMsgSteamDatagramLinkLifetimeStats::has_quality_ntile_2nd() const {
  return _internal_has_quality_ntile_2nd();
}
inline void CMsgSteamDatagramLinkLifetimeStats::clear_quality_ntile_2nd() {
  _impl_.quality_ntile_2nd_ = 0u;
  _impl_._has_bits_[0] &= ~0x00200000u;
}
inline uint32_t CMsgSteamDatagramLinkLifetimeStats::_internal_quality_ntile_2nd() const {
  return _impl_.quality_ntile_2nd_;
}
inline uint32_t CMsgSteamDatagramLinkLifetimeStats::quality_ntile_2nd() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramLinkLifetimeStats.quality_ntile_2nd)
  return _internal_quality_ntile_2nd();
}
inline void CMsgSteamDatagramLinkLifetimeStats::_internal_set_quality_ntile_2nd(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00200000u;
  _impl_.quality_ntile_2nd_ = value;
}
inline void CMsgSteamDatagramLinkLifetimeStats::set_quality_ntile_2nd(uint32_t value) {
  _internal_set_quality_ntile_2nd(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramLinkLifetimeStats.quality_ntile_2nd)
}

// optional uint32 quality_ntile_5th = 31;
inline bool CMsgSteamDatagramLinkLifetimeStats::_internal_has_quality_ntile_5th() const {
  bool value = (_impl_._has_bits_[0] & 0x00400000u) != 0;
  return value;
}
inline bool CMsgSteamDatagramLinkLifetimeStats::has_quality_ntile_5th() const {
  return _internal_has_quality_ntile_5th();
}
inline void CMsgSteamDatagramLinkLifetimeStats::clear_quality_ntile_5th() {
  _impl_.quality_ntile_5th_ = 0u;
  _impl_._has_bits_[0] &= ~0x00400000u;
}
inline uint32_t CMsgSteamDatagramLinkLifetimeStats::_internal_quality_ntile_5th() const {
  return _impl_.quality_ntile_5th_;
}
inline uint32_t CMsgSteamDatagramLinkLifetimeStats::quality_ntile_5th() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramLinkLifetimeStats.quality_ntile_5th)
  return _internal_quality_ntile_5th();
}
inline void CMsgSteamDatagramLinkLifetimeStats::_internal_set_quality_ntile_5th(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00400000u;
  _impl_.quality_ntile_5th_ = value;
}
inline void CMsgSteamDatagramLinkLifetimeStats::set_quality_ntile_5th(uint32_t value) {
  _internal_set_quality_ntile_5th(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramLinkLifetimeStats.quality_ntile_5th)
}

// optional uint32 quality_ntile_25th = 32;
inline bool CMsgSteamDatagramLinkLifetimeStats::_internal_has_quality_ntile_25th() const {
  bool value = (_impl_._has_bits_[0] & 0x00800000u) != 0;
  return value;
}
inline bool CMsgSteamDatagramLinkLifetimeStats::has_quality_ntile_25th() const {
  return _internal_has_quality_ntile_25th();
}
inline void CMsgSteamDatagramLinkLifetimeStats::clear_quality_ntile_25th() {
  _impl_.quality_ntile_25th_ = 0u;
  _impl_._has_bits_[0] &= ~0x00800000u;
}
inline uint32_t CMsgSteamDatagramLinkLifetimeStats::_internal_quality_ntile_25th() const {
  return _impl_.quality_ntile_25th_;
}
inline uint32_t CMsgSteamDatagramLinkLifetimeStats::quality_ntile_25th() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramLinkLifetimeStats.quality_ntile_25th)
  return _internal_quality_ntile_25th();
}
inline void CMsgSteamDatagramLinkLifetimeStats::_internal_set_quality_ntile_25th(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00800000u;
  _impl_.quality_ntile_25th_ = value;
}
inline void CMsgSteamDatagramLinkLifetimeStats::set_quality_ntile_25th(uint32_t value) {
  _internal_set_quality_ntile_25th(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramLinkLifetimeStats.quality_ntile_25th)
}

// optional uint32 quality_ntile_50th = 33;
inline bool CMsgSteamDatagramLinkLifetimeStats::_internal_has_quality_ntile_50th() const {
  bool value = (_impl_._has_bits_[0] & 0x01000000u) != 0;
  return value;
}
inline bool CMsgSteamDatagramLinkLifetimeStats::has_quality_ntile_50th() const {
  return _internal_has_quality_ntile_50th();
}
inline void CMsgSteamDatagramLinkLifetimeStats::clear_quality_ntile_50th() {
  _impl_.quality_ntile_50th_ = 0u;
  _impl_._has_bits_[0] &= ~0x01000000u;
}
inline uint32_t CMsgSteamDatagramLinkLifetimeStats::_internal_quality_ntile_50th() const {
  return _impl_.quality_ntile_50th_;
}
inline uint32_t CMsgSteamDatagramLinkLifetimeStats::quality_ntile_50th() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramLinkLifetimeStats.quality_ntile_50th)
  return _internal_quality_ntile_50th();
}
inline void CMsgSteamDatagramLinkLifetimeStats::_internal_set_quality_ntile_50th(uint32_t value) {
  _impl_._has_bits_[0] |= 0x01000000u;
  _impl_.quality_ntile_50th_ = value;
}
inline void CMsgSteamDatagramLinkLifetimeStats::set_quality_ntile_50th(uint32_t value) {
  _internal_set_quality_ntile_50th(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramLinkLifetimeStats.quality_ntile_50th)
}

// optional uint32 ping_histogram_25 = 41;
inline bool CMsgSteamDatagramLinkLifetimeStats::_internal_has_ping_histogram_25() const {
  bool value = (_impl_._has_bits_[0] & 0x02000000u) != 0;
  return value;
}
inline bool CMsgSteamDatagramLinkLifetimeStats::has_ping_histogram_25() const {
  return _internal_has_ping_histogram_25();
}
inline void CMsgSteamDatagramLinkLifetimeStats::clear_ping_histogram_25() {
  _impl_.ping_histogram_25_ = 0u;
  _impl_._has_bits_[0] &= ~0x02000000u;
}
inline uint32_t CMsgSteamDatagramLinkLifetimeStats::_internal_ping_histogram_25() const {
  return _impl_.ping_histogram_25_;
}
inline uint32_t CMsgSteamDatagramLinkLifetimeStats::ping_histogram_25() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramLinkLifetimeStats.ping_histogram_25)
  return _internal_ping_histogram_25();
}
inline void CMsgSteamDatagramLinkLifetimeStats::_internal_set_ping_histogram_25(uint32_t value) {
  _impl_._has_bits_[0] |= 0x02000000u;
  _impl_.ping_histogram_25_ = value;
}
inline void CMsgSteamDatagramLinkLifetimeStats::set_ping_histogram_25(uint32_t value) {
  _internal_set_ping_histogram_25(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramLinkLifetimeStats.ping_histogram_25)
}

// optional uint32 ping_histogram_50 = 42;
inline bool CMsgSteamDatagramLinkLifetimeStats::_internal_has_ping_histogram_50() const {
  bool value = (_impl_._has_bits_[0] & 0x04000000u) != 0;
  return value;
}
inline bool CMsgSteamDatagramLinkLifetimeStats::has_ping_histogram_50() const {
  return _internal_has_ping_histogram_50();
}
inline void CMsgSteamDatagramLinkLifetimeStats::clear_ping_histogram_50() {
  _impl_.ping_histogram_50_ = 0u;
  _impl_._has_bits_[0] &= ~0x04000000u;
}
inline uint32_t CMsgSteamDatagramLinkLifetimeStats::_internal_ping_histogram_50() const {
  return _impl_.ping_histogram_50_;
}
inline uint32_t CMsgSteamDatagramLinkLifetimeStats::ping_histogram_50() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramLinkLifetimeStats.ping_histogram_50)
  return _internal_ping_histogram_50();
}
inline void CMsgSteamDatagramLinkLifetimeStats::_internal_set_ping_histogram_50(uint32_t value) {
  _impl_._has_bits_[0] |= 0x04000000u;
  _impl_.ping_histogram_50_ = value;
}
inline void CMsgSteamDatagramLinkLifetimeStats::set_ping_histogram_50(uint32_t value) {
  _internal_set_ping_histogram_50(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramLinkLifetimeStats.ping_histogram_50)
}

// optional uint32 ping_histogram_75 = 43;
inline bool CMsgSteamDatagramLinkLifetimeStats::_internal_has_ping_histogram_75() const {
  bool value = (_impl_._has_bits_[0] & 0x08000000u) != 0;
  return value;
}
inline bool CMsgSteamDatagramLinkLifetimeStats::has_ping_histogram_75() const {
  return _internal_has_ping_histogram_75();
}
inline void CMsgSteamDatagramLinkLifetimeStats::clear_ping_histogram_75() {
  _impl_.ping_histogram_75_ = 0u;
  _impl_._has_bits_[0] &= ~0x08000000u;
}
inline uint32_t CMsgSteamDatagramLinkLifetimeStats::_internal_ping_histogram_75() const {
  return _impl_.ping_histogram_75_;
}
inline uint32_t CMsgSteamDatagramLinkLifetimeStats::ping_histogram_75() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramLinkLifetimeStats.ping_histogram_75)
  return _internal_ping_histogram_75();
}
inline void CMsgSteamDatagramLinkLifetimeStats::_internal_set_ping_histogram_75(uint32_t value) {
  _impl_._has_bits_[0] |= 0x08000000u;
  _impl_.ping_histogram_75_ = value;
}
inline void CMsgSteamDatagramLinkLifetimeStats::set_ping_histogram_75(uint32_t value) {
  _internal_set_ping_histogram_75(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramLinkLifetimeStats.ping_histogram_75)
}

// optional uint32 ping_histogram_100 = 44;
inline bool CMsgSteamDatagramLinkLifetimeStats::_internal_has_ping_histogram_100() const {
  bool value = (_impl_._has_bits_[0] & 0x10000000u) != 0;
  return value;
}
inline bool CMsgSteamDatagramLinkLifetimeStats::has_ping_histogram_100() const {
  return _internal_has_ping_histogram_100();
}
inline void CMsgSteamDatagramLinkLifetimeStats::clear_ping_histogram_100() {
  _impl_.ping_histogram_100_ = 0u;
  _impl_._has_bits_[0] &= ~0x10000000u;
}
inline uint32_t CMsgSteamDatagramLinkLifetimeStats::_internal_ping_histogram_100() const {
  return _impl_.ping_histogram_100_;
}
inline uint32_t CMsgSteamDatagramLinkLifetimeStats::ping_histogram_100() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramLinkLifetimeStats.ping_histogram_100)
  return _internal_ping_histogram_100();
}
inline void CMsgSteamDatagramLinkLifetimeStats::_internal_set_ping_histogram_100(uint32_t value) {
  _impl_._has_bits_[0] |= 0x10000000u;
  _impl_.ping_histogram_100_ = value;
}
inline void CMsgSteamDatagramLinkLifetimeStats::set_ping_histogram_100(uint32_t value) {
  _internal_set_ping_histogram_100(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramLinkLifetimeStats.ping_histogram_100)
}

// optional uint32 ping_histogram_125 = 45;
inline bool CMsgSteamDatagramLinkLifetimeStats::_internal_has_ping_histogram_125() const {
  bool value = (_impl_._has_bits_[0] & 0x20000000u) != 0;
  return value;
}
inline bool CMsgSteamDatagramLinkLifetimeStats::has_ping_histogram_125() const {
  return _internal_has_ping_histogram_125();
}
inline void CMsgSteamDatagramLinkLifetimeStats::clear_ping_histogram_125() {
  _impl_.ping_histogram_125_ = 0u;
  _impl_._has_bits_[0] &= ~0x20000000u;
}
inline uint32_t CMsgSteamDatagramLinkLifetimeStats::_internal_ping_histogram_125() const {
  return _impl_.ping_histogram_125_;
}
inline uint32_t CMsgSteamDatagramLinkLifetimeStats::ping_histogram_125() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramLinkLifetimeStats.ping_histogram_125)
  return _internal_ping_histogram_125();
}
inline void CMsgSteamDatagramLinkLifetimeStats::_internal_set_ping_histogram_125(uint32_t value) {
  _impl_._has_bits_[0] |= 0x20000000u;
  _impl_.ping_histogram_125_ = value;
}
inline void CMsgSteamDatagramLinkLifetimeStats::set_ping_histogram_125(uint32_t value) {
  _internal_set_ping_histogram_125(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramLinkLifetimeStats.ping_histogram_125)
}

// optional uint32 ping_histogram_150 = 46;
inline bool CMsgSteamDatagramLinkLifetimeStats::_internal_has_ping_histogram_150() const {
  bool value = (_impl_._has_bits_[0] & 0x40000000u) != 0;
  return value;
}
inline bool CMsgSteamDatagramLinkLifetimeStats::has_ping_histogram_150() const {
  return _internal_has_ping_histogram_150();
}
inline void CMsgSteamDatagramLinkLifetimeStats::clear_ping_histogram_150() {
  _impl_.ping_histogram_150_ = 0u;
  _impl_._has_bits_[0] &= ~0x40000000u;
}
inline uint32_t CMsgSteamDatagramLinkLifetimeStats::_internal_ping_histogram_150() const {
  return _impl_.ping_histogram_150_;
}
inline uint32_t CMsgSteamDatagramLinkLifetimeStats::ping_histogram_150() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramLinkLifetimeStats.ping_histogram_150)
  return _internal_ping_histogram_150();
}
inline void CMsgSteamDatagramLinkLifetimeStats::_internal_set_ping_histogram_150(uint32_t value) {
  _impl_._has_bits_[0] |= 0x40000000u;
  _impl_.ping_histogram_150_ = value;
}
inline void CMsgSteamDatagramLinkLifetimeStats::set_ping_histogram_150(uint32_t value) {
  _internal_set_ping_histogram_150(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramLinkLifetimeStats.ping_histogram_150)
}

// optional uint32 ping_histogram_200 = 47;
inline bool CMsgSteamDatagramLinkLifetimeStats::_internal_has_ping_histogram_200() const {
  bool value = (_impl_._has_bits_[0] & 0x80000000u) != 0;
  return value;
}
inline bool CMsgSteamDatagramLinkLifetimeStats::has_ping_histogram_200() const {
  return _internal_has_ping_histogram_200();
}
inline void CMsgSteamDatagramLinkLifetimeStats::clear_ping_histogram_200() {
  _impl_.ping_histogram_200_ = 0u;
  _impl_._has_bits_[0] &= ~0x80000000u;
}
inline uint32_t CMsgSteamDatagramLinkLifetimeStats::_internal_ping_histogram_200() const {
  return _impl_.ping_histogram_200_;
}
inline uint32_t CMsgSteamDatagramLinkLifetimeStats::ping_histogram_200() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramLinkLifetimeStats.ping_histogram_200)
  return _internal_ping_histogram_200();
}
inline void CMsgSteamDatagramLinkLifetimeStats::_internal_set_ping_histogram_200(uint32_t value) {
  _impl_._has_bits_[0] |= 0x80000000u;
  _impl_.ping_histogram_200_ = value;
}
inline void CMsgSteamDatagramLinkLifetimeStats::set_ping_histogram_200(uint32_t value) {
  _internal_set_ping_histogram_200(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramLinkLifetimeStats.ping_histogram_200)
}

// optional uint32 ping_histogram_300 = 48;
inline bool CMsgSteamDatagramLinkLifetimeStats::_internal_has_ping_histogram_300() const {
  bool value = (_impl_._has_bits_[1] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgSteamDatagramLinkLifetimeStats::has_ping_histogram_300() const {
  return _internal_has_ping_histogram_300();
}
inline void CMsgSteamDatagramLinkLifetimeStats::clear_ping_histogram_300() {
  _impl_.ping_histogram_300_ = 0u;
  _impl_._has_bits_[1] &= ~0x00000001u;
}
inline uint32_t CMsgSteamDatagramLinkLifetimeStats::_internal_ping_histogram_300() const {
  return _impl_.ping_histogram_300_;
}
inline uint32_t CMsgSteamDatagramLinkLifetimeStats::ping_histogram_300() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramLinkLifetimeStats.ping_histogram_300)
  return _internal_ping_histogram_300();
}
inline void CMsgSteamDatagramLinkLifetimeStats::_internal_set_ping_histogram_300(uint32_t value) {
  _impl_._has_bits_[1] |= 0x00000001u;
  _impl_.ping_histogram_300_ = value;
}
inline void CMsgSteamDatagramLinkLifetimeStats::set_ping_histogram_300(uint32_t value) {
  _internal_set_ping_histogram_300(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramLinkLifetimeStats.ping_histogram_300)
}

// optional uint32 ping_histogram_max = 49;
inline bool CMsgSteamDatagramLinkLifetimeStats::_internal_has_ping_histogram_max() const {
  bool value = (_impl_._has_bits_[1] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgSteamDatagramLinkLifetimeStats::has_ping_histogram_max() const {
  return _internal_has_ping_histogram_max();
}
inline void CMsgSteamDatagramLinkLifetimeStats::clear_ping_histogram_max() {
  _impl_.ping_histogram_max_ = 0u;
  _impl_._has_bits_[1] &= ~0x00000002u;
}
inline uint32_t CMsgSteamDatagramLinkLifetimeStats::_internal_ping_histogram_max() const {
  return _impl_.ping_histogram_max_;
}
inline uint32_t CMsgSteamDatagramLinkLifetimeStats::ping_histogram_max() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramLinkLifetimeStats.ping_histogram_max)
  return _internal_ping_histogram_max();
}
inline void CMsgSteamDatagramLinkLifetimeStats::_internal_set_ping_histogram_max(uint32_t value) {
  _impl_._has_bits_[1] |= 0x00000002u;
  _impl_.ping_histogram_max_ = value;
}
inline void CMsgSteamDatagramLinkLifetimeStats::set_ping_histogram_max(uint32_t value) {
  _internal_set_ping_histogram_max(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramLinkLifetimeStats.ping_histogram_max)
}

// optional uint32 ping_ntile_5th = 50;
inline bool CMsgSteamDatagramLinkLifetimeStats::_internal_has_ping_ntile_5th() const {
  bool value = (_impl_._has_bits_[1] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgSteamDatagramLinkLifetimeStats::has_ping_ntile_5th() const {
  return _internal_has_ping_ntile_5th();
}
inline void CMsgSteamDatagramLinkLifetimeStats::clear_ping_ntile_5th() {
  _impl_.ping_ntile_5th_ = 0u;
  _impl_._has_bits_[1] &= ~0x00000004u;
}
inline uint32_t CMsgSteamDatagramLinkLifetimeStats::_internal_ping_ntile_5th() const {
  return _impl_.ping_ntile_5th_;
}
inline uint32_t CMsgSteamDatagramLinkLifetimeStats::ping_ntile_5th() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramLinkLifetimeStats.ping_ntile_5th)
  return _internal_ping_ntile_5th();
}
inline void CMsgSteamDatagramLinkLifetimeStats::_internal_set_ping_ntile_5th(uint32_t value) {
  _impl_._has_bits_[1] |= 0x00000004u;
  _impl_.ping_ntile_5th_ = value;
}
inline void CMsgSteamDatagramLinkLifetimeStats::set_ping_ntile_5th(uint32_t value) {
  _internal_set_ping_ntile_5th(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramLinkLifetimeStats.ping_ntile_5th)
}

// optional uint32 ping_ntile_50th = 51;
inline bool CMsgSteamDatagramLinkLifetimeStats::_internal_has_ping_ntile_50th() const {
  bool value = (_impl_._has_bits_[1] & 0x00000008u) != 0;
  return value;
}
inline bool CMsgSteamDatagramLinkLifetimeStats::has_ping_ntile_50th() const {
  return _internal_has_ping_ntile_50th();
}
inline void CMsgSteamDatagramLinkLifetimeStats::clear_ping_ntile_50th() {
  _impl_.ping_ntile_50th_ = 0u;
  _impl_._has_bits_[1] &= ~0x00000008u;
}
inline uint32_t CMsgSteamDatagramLinkLifetimeStats::_internal_ping_ntile_50th() const {
  return _impl_.ping_ntile_50th_;
}
inline uint32_t CMsgSteamDatagramLinkLifetimeStats::ping_ntile_50th() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramLinkLifetimeStats.ping_ntile_50th)
  return _internal_ping_ntile_50th();
}
inline void CMsgSteamDatagramLinkLifetimeStats::_internal_set_ping_ntile_50th(uint32_t value) {
  _impl_._has_bits_[1] |= 0x00000008u;
  _impl_.ping_ntile_50th_ = value;
}
inline void CMsgSteamDatagramLinkLifetimeStats::set_ping_ntile_50th(uint32_t value) {
  _internal_set_ping_ntile_50th(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramLinkLifetimeStats.ping_ntile_50th)
}

// optional uint32 ping_ntile_75th = 52;
inline bool CMsgSteamDatagramLinkLifetimeStats::_internal_has_ping_ntile_75th() const {
  bool value = (_impl_._has_bits_[1] & 0x00000010u) != 0;
  return value;
}
inline bool CMsgSteamDatagramLinkLifetimeStats::has_ping_ntile_75th() const {
  return _internal_has_ping_ntile_75th();
}
inline void CMsgSteamDatagramLinkLifetimeStats::clear_ping_ntile_75th() {
  _impl_.ping_ntile_75th_ = 0u;
  _impl_._has_bits_[1] &= ~0x00000010u;
}
inline uint32_t CMsgSteamDatagramLinkLifetimeStats::_internal_ping_ntile_75th() const {
  return _impl_.ping_ntile_75th_;
}
inline uint32_t CMsgSteamDatagramLinkLifetimeStats::ping_ntile_75th() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramLinkLifetimeStats.ping_ntile_75th)
  return _internal_ping_ntile_75th();
}
inline void CMsgSteamDatagramLinkLifetimeStats::_internal_set_ping_ntile_75th(uint32_t value) {
  _impl_._has_bits_[1] |= 0x00000010u;
  _impl_.ping_ntile_75th_ = value;
}
inline void CMsgSteamDatagramLinkLifetimeStats::set_ping_ntile_75th(uint32_t value) {
  _internal_set_ping_ntile_75th(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramLinkLifetimeStats.ping_ntile_75th)
}

// optional uint32 ping_ntile_95th = 53;
inline bool CMsgSteamDatagramLinkLifetimeStats::_internal_has_ping_ntile_95th() const {
  bool value = (_impl_._has_bits_[1] & 0x00000020u) != 0;
  return value;
}
inline bool CMsgSteamDatagramLinkLifetimeStats::has_ping_ntile_95th() const {
  return _internal_has_ping_ntile_95th();
}
inline void CMsgSteamDatagramLinkLifetimeStats::clear_ping_ntile_95th() {
  _impl_.ping_ntile_95th_ = 0u;
  _impl_._has_bits_[1] &= ~0x00000020u;
}
inline uint32_t CMsgSteamDatagramLinkLifetimeStats::_internal_ping_ntile_95th() const {
  return _impl_.ping_ntile_95th_;
}
inline uint32_t CMsgSteamDatagramLinkLifetimeStats::ping_ntile_95th() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramLinkLifetimeStats.ping_ntile_95th)
  return _internal_ping_ntile_95th();
}
inline void CMsgSteamDatagramLinkLifetimeStats::_internal_set_ping_ntile_95th(uint32_t value) {
  _impl_._has_bits_[1] |= 0x00000020u;
  _impl_.ping_ntile_95th_ = value;
}
inline void CMsgSteamDatagramLinkLifetimeStats::set_ping_ntile_95th(uint32_t value) {
  _internal_set_ping_ntile_95th(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramLinkLifetimeStats.ping_ntile_95th)
}

// optional uint32 ping_ntile_98th = 54;
inline bool CMsgSteamDatagramLinkLifetimeStats::_internal_has_ping_ntile_98th() const {
  bool value = (_impl_._has_bits_[1] & 0x00000040u) != 0;
  return value;
}
inline bool CMsgSteamDatagramLinkLifetimeStats::has_ping_ntile_98th() const {
  return _internal_has_ping_ntile_98th();
}
inline void CMsgSteamDatagramLinkLifetimeStats::clear_ping_ntile_98th() {
  _impl_.ping_ntile_98th_ = 0u;
  _impl_._has_bits_[1] &= ~0x00000040u;
}
inline uint32_t CMsgSteamDatagramLinkLifetimeStats::_internal_ping_ntile_98th() const {
  return _impl_.ping_ntile_98th_;
}
inline uint32_t CMsgSteamDatagramLinkLifetimeStats::ping_ntile_98th() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramLinkLifetimeStats.ping_ntile_98th)
  return _internal_ping_ntile_98th();
}
inline void CMsgSteamDatagramLinkLifetimeStats::_internal_set_ping_ntile_98th(uint32_t value) {
  _impl_._has_bits_[1] |= 0x00000040u;
  _impl_.ping_ntile_98th_ = value;
}
inline void CMsgSteamDatagramLinkLifetimeStats::set_ping_ntile_98th(uint32_t value) {
  _internal_set_ping_ntile_98th(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramLinkLifetimeStats.ping_ntile_98th)
}

// optional uint32 jitter_histogram_negligible = 61;
inline bool CMsgSteamDatagramLinkLifetimeStats::_internal_has_jitter_histogram_negligible() const {
  bool value = (_impl_._has_bits_[1] & 0x00000080u) != 0;
  return value;
}
inline bool CMsgSteamDatagramLinkLifetimeStats::has_jitter_histogram_negligible() const {
  return _internal_has_jitter_histogram_negligible();
}
inline void CMsgSteamDatagramLinkLifetimeStats::clear_jitter_histogram_negligible() {
  _impl_.jitter_histogram_negligible_ = 0u;
  _impl_._has_bits_[1] &= ~0x00000080u;
}
inline uint32_t CMsgSteamDatagramLinkLifetimeStats::_internal_jitter_histogram_negligible() const {
  return _impl_.jitter_histogram_negligible_;
}
inline uint32_t CMsgSteamDatagramLinkLifetimeStats::jitter_histogram_negligible() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramLinkLifetimeStats.jitter_histogram_negligible)
  return _internal_jitter_histogram_negligible();
}
inline void CMsgSteamDatagramLinkLifetimeStats::_internal_set_jitter_histogram_negligible(uint32_t value) {
  _impl_._has_bits_[1] |= 0x00000080u;
  _impl_.jitter_histogram_negligible_ = value;
}
inline void CMsgSteamDatagramLinkLifetimeStats::set_jitter_histogram_negligible(uint32_t value) {
  _internal_set_jitter_histogram_negligible(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramLinkLifetimeStats.jitter_histogram_negligible)
}

// optional uint32 jitter_histogram_1 = 62;
inline bool CMsgSteamDatagramLinkLifetimeStats::_internal_has_jitter_histogram_1() const {
  bool value = (_impl_._has_bits_[1] & 0x00000100u) != 0;
  return value;
}
inline bool CMsgSteamDatagramLinkLifetimeStats::has_jitter_histogram_1() const {
  return _internal_has_jitter_histogram_1();
}
inline void CMsgSteamDatagramLinkLifetimeStats::clear_jitter_histogram_1() {
  _impl_.jitter_histogram_1_ = 0u;
  _impl_._has_bits_[1] &= ~0x00000100u;
}
inline uint32_t CMsgSteamDatagramLinkLifetimeStats::_internal_jitter_histogram_1() const {
  return _impl_.jitter_histogram_1_;
}
inline uint32_t CMsgSteamDatagramLinkLifetimeStats::jitter_histogram_1() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramLinkLifetimeStats.jitter_histogram_1)
  return _internal_jitter_histogram_1();
}
inline void CMsgSteamDatagramLinkLifetimeStats::_internal_set_jitter_histogram_1(uint32_t value) {
  _impl_._has_bits_[1] |= 0x00000100u;
  _impl_.jitter_histogram_1_ = value;
}
inline void CMsgSteamDatagramLinkLifetimeStats::set_jitter_histogram_1(uint32_t value) {
  _internal_set_jitter_histogram_1(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramLinkLifetimeStats.jitter_histogram_1)
}

// optional uint32 jitter_histogram_2 = 63;
inline bool CMsgSteamDatagramLinkLifetimeStats::_internal_has_jitter_histogram_2() const {
  bool value = (_impl_._has_bits_[1] & 0x00000200u) != 0;
  return value;
}
inline bool CMsgSteamDatagramLinkLifetimeStats::has_jitter_histogram_2() const {
  return _internal_has_jitter_histogram_2();
}
inline void CMsgSteamDatagramLinkLifetimeStats::clear_jitter_histogram_2() {
  _impl_.jitter_histogram_2_ = 0u;
  _impl_._has_bits_[1] &= ~0x00000200u;
}
inline uint32_t CMsgSteamDatagramLinkLifetimeStats::_internal_jitter_histogram_2() const {
  return _impl_.jitter_histogram_2_;
}
inline uint32_t CMsgSteamDatagramLinkLifetimeStats::jitter_histogram_2() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramLinkLifetimeStats.jitter_histogram_2)
  return _internal_jitter_histogram_2();
}
inline void CMsgSteamDatagramLinkLifetimeStats::_internal_set_jitter_histogram_2(uint32_t value) {
  _impl_._has_bits_[1] |= 0x00000200u;
  _impl_.jitter_histogram_2_ = value;
}
inline void CMsgSteamDatagramLinkLifetimeStats::set_jitter_histogram_2(uint32_t value) {
  _internal_set_jitter_histogram_2(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramLinkLifetimeStats.jitter_histogram_2)
}

// optional uint32 jitter_histogram_5 = 64;
inline bool CMsgSteamDatagramLinkLifetimeStats::_internal_has_jitter_histogram_5() const {
  bool value = (_impl_._has_bits_[1] & 0x00000400u) != 0;
  return value;
}
inline bool CMsgSteamDatagramLinkLifetimeStats::has_jitter_histogram_5() const {
  return _internal_has_jitter_histogram_5();
}
inline void CMsgSteamDatagramLinkLifetimeStats::clear_jitter_histogram_5() {
  _impl_.jitter_histogram_5_ = 0u;
  _impl_._has_bits_[1] &= ~0x00000400u;
}
inline uint32_t CMsgSteamDatagramLinkLifetimeStats::_internal_jitter_histogram_5() const {
  return _impl_.jitter_histogram_5_;
}
inline uint32_t CMsgSteamDatagramLinkLifetimeStats::jitter_histogram_5() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramLinkLifetimeStats.jitter_histogram_5)
  return _internal_jitter_histogram_5();
}
inline void CMsgSteamDatagramLinkLifetimeStats::_internal_set_jitter_histogram_5(uint32_t value) {
  _impl_._has_bits_[1] |= 0x00000400u;
  _impl_.jitter_histogram_5_ = value;
}
inline void CMsgSteamDatagramLinkLifetimeStats::set_jitter_histogram_5(uint32_t value) {
  _internal_set_jitter_histogram_5(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramLinkLifetimeStats.jitter_histogram_5)
}

// optional uint32 jitter_histogram_10 = 65;
inline bool CMsgSteamDatagramLinkLifetimeStats::_internal_has_jitter_histogram_10() const {
  bool value = (_impl_._has_bits_[1] & 0x00000800u) != 0;
  return value;
}
inline bool CMsgSteamDatagramLinkLifetimeStats::has_jitter_histogram_10() const {
  return _internal_has_jitter_histogram_10();
}
inline void CMsgSteamDatagramLinkLifetimeStats::clear_jitter_histogram_10() {
  _impl_.jitter_histogram_10_ = 0u;
  _impl_._has_bits_[1] &= ~0x00000800u;
}
inline uint32_t CMsgSteamDatagramLinkLifetimeStats::_internal_jitter_histogram_10() const {
  return _impl_.jitter_histogram_10_;
}
inline uint32_t CMsgSteamDatagramLinkLifetimeStats::jitter_histogram_10() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramLinkLifetimeStats.jitter_histogram_10)
  return _internal_jitter_histogram_10();
}
inline void CMsgSteamDatagramLinkLifetimeStats::_internal_set_jitter_histogram_10(uint32_t value) {
  _impl_._has_bits_[1] |= 0x00000800u;
  _impl_.jitter_histogram_10_ = value;
}
inline void CMsgSteamDatagramLinkLifetimeStats::set_jitter_histogram_10(uint32_t value) {
  _internal_set_jitter_histogram_10(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramLinkLifetimeStats.jitter_histogram_10)
}

// optional uint32 jitter_histogram_20 = 66;
inline bool CMsgSteamDatagramLinkLifetimeStats::_internal_has_jitter_histogram_20() const {
  bool value = (_impl_._has_bits_[1] & 0x00001000u) != 0;
  return value;
}
inline bool CMsgSteamDatagramLinkLifetimeStats::has_jitter_histogram_20() const {
  return _internal_has_jitter_histogram_20();
}
inline void CMsgSteamDatagramLinkLifetimeStats::clear_jitter_histogram_20() {
  _impl_.jitter_histogram_20_ = 0u;
  _impl_._has_bits_[1] &= ~0x00001000u;
}
inline uint32_t CMsgSteamDatagramLinkLifetimeStats::_internal_jitter_histogram_20() const {
  return _impl_.jitter_histogram_20_;
}
inline uint32_t CMsgSteamDatagramLinkLifetimeStats::jitter_histogram_20() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramLinkLifetimeStats.jitter_histogram_20)
  return _internal_jitter_histogram_20();
}
inline void CMsgSteamDatagramLinkLifetimeStats::_internal_set_jitter_histogram_20(uint32_t value) {
  _impl_._has_bits_[1] |= 0x00001000u;
  _impl_.jitter_histogram_20_ = value;
}
inline void CMsgSteamDatagramLinkLifetimeStats::set_jitter_histogram_20(uint32_t value) {
  _internal_set_jitter_histogram_20(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramLinkLifetimeStats.jitter_histogram_20)
}

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

// CMsgSteamDatagramConnectionQuality

// optional .CMsgSteamDatagramLinkInstantaneousStats instantaneous = 1;
inline bool CMsgSteamDatagramConnectionQuality::_internal_has_instantaneous() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.instantaneous_ != nullptr);
  return value;
}
inline bool CMsgSteamDatagramConnectionQuality::has_instantaneous() const {
  return _internal_has_instantaneous();
}
inline void CMsgSteamDatagramConnectionQuality::clear_instantaneous() {
  if (_impl_.instantaneous_ != nullptr) _impl_.instantaneous_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::CMsgSteamDatagramLinkInstantaneousStats& CMsgSteamDatagramConnectionQuality::_internal_instantaneous() const {
  const ::CMsgSteamDatagramLinkInstantaneousStats* p = _impl_.instantaneous_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgSteamDatagramLinkInstantaneousStats&>(
      ::_CMsgSteamDatagramLinkInstantaneousStats_default_instance_);
}
inline const ::CMsgSteamDatagramLinkInstantaneousStats& CMsgSteamDatagramConnectionQuality::instantaneous() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectionQuality.instantaneous)
  return _internal_instantaneous();
}
inline void CMsgSteamDatagramConnectionQuality::unsafe_arena_set_allocated_instantaneous(
    ::CMsgSteamDatagramLinkInstantaneousStats* instantaneous) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.instantaneous_);
  }
  _impl_.instantaneous_ = instantaneous;
  if (instantaneous) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgSteamDatagramConnectionQuality.instantaneous)
}
inline ::CMsgSteamDatagramLinkInstantaneousStats* CMsgSteamDatagramConnectionQuality::release_instantaneous() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgSteamDatagramLinkInstantaneousStats* temp = _impl_.instantaneous_;
  _impl_.instantaneous_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::CMsgSteamDatagramLinkInstantaneousStats* CMsgSteamDatagramConnectionQuality::unsafe_arena_release_instantaneous() {
  // @@protoc_insertion_point(field_release:CMsgSteamDatagramConnectionQuality.instantaneous)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgSteamDatagramLinkInstantaneousStats* temp = _impl_.instantaneous_;
  _impl_.instantaneous_ = nullptr;
  return temp;
}
inline ::CMsgSteamDatagramLinkInstantaneousStats* CMsgSteamDatagramConnectionQuality::_internal_mutable_instantaneous() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.instantaneous_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgSteamDatagramLinkInstantaneousStats>(GetArenaForAllocation());
    _impl_.instantaneous_ = p;
  }
  return _impl_.instantaneous_;
}
inline ::CMsgSteamDatagramLinkInstantaneousStats* CMsgSteamDatagramConnectionQuality::mutable_instantaneous() {
  ::CMsgSteamDatagramLinkInstantaneousStats* _msg = _internal_mutable_instantaneous();
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramConnectionQuality.instantaneous)
  return _msg;
}
inline void CMsgSteamDatagramConnectionQuality::set_allocated_instantaneous(::CMsgSteamDatagramLinkInstantaneousStats* instantaneous) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.instantaneous_;
  }
  if (instantaneous) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(instantaneous);
    if (message_arena != submessage_arena) {
      instantaneous = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, instantaneous, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.instantaneous_ = instantaneous;
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamDatagramConnectionQuality.instantaneous)
}

// optional .CMsgSteamDatagramLinkLifetimeStats lifetime = 2;
inline bool CMsgSteamDatagramConnectionQuality::_internal_has_lifetime() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.lifetime_ != nullptr);
  return value;
}
inline bool CMsgSteamDatagramConnectionQuality::has_lifetime() const {
  return _internal_has_lifetime();
}
inline void CMsgSteamDatagramConnectionQuality::clear_lifetime() {
  if (_impl_.lifetime_ != nullptr) _impl_.lifetime_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::CMsgSteamDatagramLinkLifetimeStats& CMsgSteamDatagramConnectionQuality::_internal_lifetime() const {
  const ::CMsgSteamDatagramLinkLifetimeStats* p = _impl_.lifetime_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgSteamDatagramLinkLifetimeStats&>(
      ::_CMsgSteamDatagramLinkLifetimeStats_default_instance_);
}
inline const ::CMsgSteamDatagramLinkLifetimeStats& CMsgSteamDatagramConnectionQuality::lifetime() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectionQuality.lifetime)
  return _internal_lifetime();
}
inline void CMsgSteamDatagramConnectionQuality::unsafe_arena_set_allocated_lifetime(
    ::CMsgSteamDatagramLinkLifetimeStats* lifetime) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.lifetime_);
  }
  _impl_.lifetime_ = lifetime;
  if (lifetime) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgSteamDatagramConnectionQuality.lifetime)
}
inline ::CMsgSteamDatagramLinkLifetimeStats* CMsgSteamDatagramConnectionQuality::release_lifetime() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgSteamDatagramLinkLifetimeStats* temp = _impl_.lifetime_;
  _impl_.lifetime_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::CMsgSteamDatagramLinkLifetimeStats* CMsgSteamDatagramConnectionQuality::unsafe_arena_release_lifetime() {
  // @@protoc_insertion_point(field_release:CMsgSteamDatagramConnectionQuality.lifetime)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgSteamDatagramLinkLifetimeStats* temp = _impl_.lifetime_;
  _impl_.lifetime_ = nullptr;
  return temp;
}
inline ::CMsgSteamDatagramLinkLifetimeStats* CMsgSteamDatagramConnectionQuality::_internal_mutable_lifetime() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.lifetime_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgSteamDatagramLinkLifetimeStats>(GetArenaForAllocation());
    _impl_.lifetime_ = p;
  }
  return _impl_.lifetime_;
}
inline ::CMsgSteamDatagramLinkLifetimeStats* CMsgSteamDatagramConnectionQuality::mutable_lifetime() {
  ::CMsgSteamDatagramLinkLifetimeStats* _msg = _internal_mutable_lifetime();
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramConnectionQuality.lifetime)
  return _msg;
}
inline void CMsgSteamDatagramConnectionQuality::set_allocated_lifetime(::CMsgSteamDatagramLinkLifetimeStats* lifetime) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.lifetime_;
  }
  if (lifetime) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(lifetime);
    if (message_arena != submessage_arena) {
      lifetime = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, lifetime, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.lifetime_ = lifetime;
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamDatagramConnectionQuality.lifetime)
}

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

// CMsgICECandidate

// optional string candidate = 3;
inline bool CMsgICECandidate::_internal_has_candidate() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgICECandidate::has_candidate() const {
  return _internal_has_candidate();
}
inline void CMsgICECandidate::clear_candidate() {
  _impl_.candidate_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CMsgICECandidate::candidate() const {
  // @@protoc_insertion_point(field_get:CMsgICECandidate.candidate)
  return _internal_candidate();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgICECandidate::set_candidate(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.candidate_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgICECandidate.candidate)
}
inline std::string* CMsgICECandidate::mutable_candidate() {
  std::string* _s = _internal_mutable_candidate();
  // @@protoc_insertion_point(field_mutable:CMsgICECandidate.candidate)
  return _s;
}
inline const std::string& CMsgICECandidate::_internal_candidate() const {
  return _impl_.candidate_.Get();
}
inline void CMsgICECandidate::_internal_set_candidate(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.candidate_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgICECandidate::_internal_mutable_candidate() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.candidate_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgICECandidate::release_candidate() {
  // @@protoc_insertion_point(field_release:CMsgICECandidate.candidate)
  if (!_internal_has_candidate()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.candidate_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.candidate_.IsDefault()) {
    _impl_.candidate_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgICECandidate::set_allocated_candidate(std::string* candidate) {
  if (candidate != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.candidate_.SetAllocated(candidate, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.candidate_.IsDefault()) {
    _impl_.candidate_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgICECandidate.candidate)
}

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

// CMsgICERendezvous_Auth

// optional string pwd_frag = 1;
inline bool CMsgICERendezvous_Auth::_internal_has_pwd_frag() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgICERendezvous_Auth::has_pwd_frag() const {
  return _internal_has_pwd_frag();
}
inline void CMsgICERendezvous_Auth::clear_pwd_frag() {
  _impl_.pwd_frag_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CMsgICERendezvous_Auth::pwd_frag() const {
  // @@protoc_insertion_point(field_get:CMsgICERendezvous.Auth.pwd_frag)
  return _internal_pwd_frag();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgICERendezvous_Auth::set_pwd_frag(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.pwd_frag_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgICERendezvous.Auth.pwd_frag)
}
inline std::string* CMsgICERendezvous_Auth::mutable_pwd_frag() {
  std::string* _s = _internal_mutable_pwd_frag();
  // @@protoc_insertion_point(field_mutable:CMsgICERendezvous.Auth.pwd_frag)
  return _s;
}
inline const std::string& CMsgICERendezvous_Auth::_internal_pwd_frag() const {
  return _impl_.pwd_frag_.Get();
}
inline void CMsgICERendezvous_Auth::_internal_set_pwd_frag(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.pwd_frag_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgICERendezvous_Auth::_internal_mutable_pwd_frag() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.pwd_frag_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgICERendezvous_Auth::release_pwd_frag() {
  // @@protoc_insertion_point(field_release:CMsgICERendezvous.Auth.pwd_frag)
  if (!_internal_has_pwd_frag()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.pwd_frag_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.pwd_frag_.IsDefault()) {
    _impl_.pwd_frag_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgICERendezvous_Auth::set_allocated_pwd_frag(std::string* pwd_frag) {
  if (pwd_frag != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.pwd_frag_.SetAllocated(pwd_frag, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.pwd_frag_.IsDefault()) {
    _impl_.pwd_frag_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgICERendezvous.Auth.pwd_frag)
}

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

// CMsgICERendezvous

// optional .CMsgICERendezvous.Auth auth = 2;
inline bool CMsgICERendezvous::_internal_has_auth() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.auth_ != nullptr);
  return value;
}
inline bool CMsgICERendezvous::has_auth() const {
  return _internal_has_auth();
}
inline void CMsgICERendezvous::clear_auth() {
  if (_impl_.auth_ != nullptr) _impl_.auth_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::CMsgICERendezvous_Auth& CMsgICERendezvous::_internal_auth() const {
  const ::CMsgICERendezvous_Auth* p = _impl_.auth_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgICERendezvous_Auth&>(
      ::_CMsgICERendezvous_Auth_default_instance_);
}
inline const ::CMsgICERendezvous_Auth& CMsgICERendezvous::auth() const {
  // @@protoc_insertion_point(field_get:CMsgICERendezvous.auth)
  return _internal_auth();
}
inline void CMsgICERendezvous::unsafe_arena_set_allocated_auth(
    ::CMsgICERendezvous_Auth* auth) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.auth_);
  }
  _impl_.auth_ = auth;
  if (auth) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgICERendezvous.auth)
}
inline ::CMsgICERendezvous_Auth* CMsgICERendezvous::release_auth() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgICERendezvous_Auth* temp = _impl_.auth_;
  _impl_.auth_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::CMsgICERendezvous_Auth* CMsgICERendezvous::unsafe_arena_release_auth() {
  // @@protoc_insertion_point(field_release:CMsgICERendezvous.auth)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgICERendezvous_Auth* temp = _impl_.auth_;
  _impl_.auth_ = nullptr;
  return temp;
}
inline ::CMsgICERendezvous_Auth* CMsgICERendezvous::_internal_mutable_auth() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.auth_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgICERendezvous_Auth>(GetArenaForAllocation());
    _impl_.auth_ = p;
  }
  return _impl_.auth_;
}
inline ::CMsgICERendezvous_Auth* CMsgICERendezvous::mutable_auth() {
  ::CMsgICERendezvous_Auth* _msg = _internal_mutable_auth();
  // @@protoc_insertion_point(field_mutable:CMsgICERendezvous.auth)
  return _msg;
}
inline void CMsgICERendezvous::set_allocated_auth(::CMsgICERendezvous_Auth* auth) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.auth_;
  }
  if (auth) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(auth);
    if (message_arena != submessage_arena) {
      auth = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, auth, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.auth_ = auth;
  // @@protoc_insertion_point(field_set_allocated:CMsgICERendezvous.auth)
}

// optional .CMsgICECandidate add_candidate = 1;
inline bool CMsgICERendezvous::_internal_has_add_candidate() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.add_candidate_ != nullptr);
  return value;
}
inline bool CMsgICERendezvous::has_add_candidate() const {
  return _internal_has_add_candidate();
}
inline void CMsgICERendezvous::clear_add_candidate() {
  if (_impl_.add_candidate_ != nullptr) _impl_.add_candidate_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::CMsgICECandidate& CMsgICERendezvous::_internal_add_candidate() const {
  const ::CMsgICECandidate* p = _impl_.add_candidate_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgICECandidate&>(
      ::_CMsgICECandidate_default_instance_);
}
inline const ::CMsgICECandidate& CMsgICERendezvous::add_candidate() const {
  // @@protoc_insertion_point(field_get:CMsgICERendezvous.add_candidate)
  return _internal_add_candidate();
}
inline void CMsgICERendezvous::unsafe_arena_set_allocated_add_candidate(
    ::CMsgICECandidate* add_candidate) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.add_candidate_);
  }
  _impl_.add_candidate_ = add_candidate;
  if (add_candidate) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgICERendezvous.add_candidate)
}
inline ::CMsgICECandidate* CMsgICERendezvous::release_add_candidate() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgICECandidate* temp = _impl_.add_candidate_;
  _impl_.add_candidate_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::CMsgICECandidate* CMsgICERendezvous::unsafe_arena_release_add_candidate() {
  // @@protoc_insertion_point(field_release:CMsgICERendezvous.add_candidate)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgICECandidate* temp = _impl_.add_candidate_;
  _impl_.add_candidate_ = nullptr;
  return temp;
}
inline ::CMsgICECandidate* CMsgICERendezvous::_internal_mutable_add_candidate() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.add_candidate_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgICECandidate>(GetArenaForAllocation());
    _impl_.add_candidate_ = p;
  }
  return _impl_.add_candidate_;
}
inline ::CMsgICECandidate* CMsgICERendezvous::mutable_add_candidate() {
  ::CMsgICECandidate* _msg = _internal_mutable_add_candidate();
  // @@protoc_insertion_point(field_mutable:CMsgICERendezvous.add_candidate)
  return _msg;
}
inline void CMsgICERendezvous::set_allocated_add_candidate(::CMsgICECandidate* add_candidate) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.add_candidate_;
  }
  if (add_candidate) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(add_candidate);
    if (message_arena != submessage_arena) {
      add_candidate = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, add_candidate, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.add_candidate_ = add_candidate;
  // @@protoc_insertion_point(field_set_allocated:CMsgICERendezvous.add_candidate)
}

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

// CMsgSteamNetworkingP2PRendezvous_ConnectRequest

// optional .CMsgSteamDatagramSessionCryptInfoSigned crypt = 6;
inline bool CMsgSteamNetworkingP2PRendezvous_ConnectRequest::_internal_has_crypt() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.crypt_ != nullptr);
  return value;
}
inline bool CMsgSteamNetworkingP2PRendezvous_ConnectRequest::has_crypt() const {
  return _internal_has_crypt();
}
inline void CMsgSteamNetworkingP2PRendezvous_ConnectRequest::clear_crypt() {
  if (_impl_.crypt_ != nullptr) _impl_.crypt_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::CMsgSteamDatagramSessionCryptInfoSigned& CMsgSteamNetworkingP2PRendezvous_ConnectRequest::_internal_crypt() const {
  const ::CMsgSteamDatagramSessionCryptInfoSigned* p = _impl_.crypt_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgSteamDatagramSessionCryptInfoSigned&>(
      ::_CMsgSteamDatagramSessionCryptInfoSigned_default_instance_);
}
inline const ::CMsgSteamDatagramSessionCryptInfoSigned& CMsgSteamNetworkingP2PRendezvous_ConnectRequest::crypt() const {
  // @@protoc_insertion_point(field_get:CMsgSteamNetworkingP2PRendezvous.ConnectRequest.crypt)
  return _internal_crypt();
}
inline void CMsgSteamNetworkingP2PRendezvous_ConnectRequest::unsafe_arena_set_allocated_crypt(
    ::CMsgSteamDatagramSessionCryptInfoSigned* crypt) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.crypt_);
  }
  _impl_.crypt_ = crypt;
  if (crypt) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgSteamNetworkingP2PRendezvous.ConnectRequest.crypt)
}
inline ::CMsgSteamDatagramSessionCryptInfoSigned* CMsgSteamNetworkingP2PRendezvous_ConnectRequest::release_crypt() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgSteamDatagramSessionCryptInfoSigned* temp = _impl_.crypt_;
  _impl_.crypt_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::CMsgSteamDatagramSessionCryptInfoSigned* CMsgSteamNetworkingP2PRendezvous_ConnectRequest::unsafe_arena_release_crypt() {
  // @@protoc_insertion_point(field_release:CMsgSteamNetworkingP2PRendezvous.ConnectRequest.crypt)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgSteamDatagramSessionCryptInfoSigned* temp = _impl_.crypt_;
  _impl_.crypt_ = nullptr;
  return temp;
}
inline ::CMsgSteamDatagramSessionCryptInfoSigned* CMsgSteamNetworkingP2PRendezvous_ConnectRequest::_internal_mutable_crypt() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.crypt_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgSteamDatagramSessionCryptInfoSigned>(GetArenaForAllocation());
    _impl_.crypt_ = p;
  }
  return _impl_.crypt_;
}
inline ::CMsgSteamDatagramSessionCryptInfoSigned* CMsgSteamNetworkingP2PRendezvous_ConnectRequest::mutable_crypt() {
  ::CMsgSteamDatagramSessionCryptInfoSigned* _msg = _internal_mutable_crypt();
  // @@protoc_insertion_point(field_mutable:CMsgSteamNetworkingP2PRendezvous.ConnectRequest.crypt)
  return _msg;
}
inline void CMsgSteamNetworkingP2PRendezvous_ConnectRequest::set_allocated_crypt(::CMsgSteamDatagramSessionCryptInfoSigned* crypt) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.crypt_;
  }
  if (crypt) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(crypt);
    if (message_arena != submessage_arena) {
      crypt = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, crypt, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.crypt_ = crypt;
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamNetworkingP2PRendezvous.ConnectRequest.crypt)
}

// optional .CMsgSteamDatagramCertificateSigned cert = 7;
inline bool CMsgSteamNetworkingP2PRendezvous_ConnectRequest::_internal_has_cert() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.cert_ != nullptr);
  return value;
}
inline bool CMsgSteamNetworkingP2PRendezvous_ConnectRequest::has_cert() const {
  return _internal_has_cert();
}
inline const ::CMsgSteamDatagramCertificateSigned& CMsgSteamNetworkingP2PRendezvous_ConnectRequest::_internal_cert() const {
  const ::CMsgSteamDatagramCertificateSigned* p = _impl_.cert_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgSteamDatagramCertificateSigned&>(
      ::_CMsgSteamDatagramCertificateSigned_default_instance_);
}
inline const ::CMsgSteamDatagramCertificateSigned& CMsgSteamNetworkingP2PRendezvous_ConnectRequest::cert() const {
  // @@protoc_insertion_point(field_get:CMsgSteamNetworkingP2PRendezvous.ConnectRequest.cert)
  return _internal_cert();
}
inline void CMsgSteamNetworkingP2PRendezvous_ConnectRequest::unsafe_arena_set_allocated_cert(
    ::CMsgSteamDatagramCertificateSigned* cert) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.cert_);
  }
  _impl_.cert_ = cert;
  if (cert) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgSteamNetworkingP2PRendezvous.ConnectRequest.cert)
}
inline ::CMsgSteamDatagramCertificateSigned* CMsgSteamNetworkingP2PRendezvous_ConnectRequest::release_cert() {
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::CMsgSteamDatagramCertificateSigned* temp = _impl_.cert_;
  _impl_.cert_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::CMsgSteamDatagramCertificateSigned* CMsgSteamNetworkingP2PRendezvous_ConnectRequest::unsafe_arena_release_cert() {
  // @@protoc_insertion_point(field_release:CMsgSteamNetworkingP2PRendezvous.ConnectRequest.cert)
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::CMsgSteamDatagramCertificateSigned* temp = _impl_.cert_;
  _impl_.cert_ = nullptr;
  return temp;
}
inline ::CMsgSteamDatagramCertificateSigned* CMsgSteamNetworkingP2PRendezvous_ConnectRequest::_internal_mutable_cert() {
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.cert_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgSteamDatagramCertificateSigned>(GetArenaForAllocation());
    _impl_.cert_ = p;
  }
  return _impl_.cert_;
}
inline ::CMsgSteamDatagramCertificateSigned* CMsgSteamNetworkingP2PRendezvous_ConnectRequest::mutable_cert() {
  ::CMsgSteamDatagramCertificateSigned* _msg = _internal_mutable_cert();
  // @@protoc_insertion_point(field_mutable:CMsgSteamNetworkingP2PRendezvous.ConnectRequest.cert)
  return _msg;
}
inline void CMsgSteamNetworkingP2PRendezvous_ConnectRequest::set_allocated_cert(::CMsgSteamDatagramCertificateSigned* cert) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.cert_);
  }
  if (cert) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(cert));
    if (message_arena != submessage_arena) {
      cert = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, cert, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.cert_ = cert;
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamNetworkingP2PRendezvous.ConnectRequest.cert)
}

// optional uint32 to_virtual_port = 9;
inline bool CMsgSteamNetworkingP2PRendezvous_ConnectRequest::_internal_has_to_virtual_port() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CMsgSteamNetworkingP2PRendezvous_ConnectRequest::has_to_virtual_port() const {
  return _internal_has_to_virtual_port();
}
inline void CMsgSteamNetworkingP2PRendezvous_ConnectRequest::clear_to_virtual_port() {
  _impl_.to_virtual_port_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t CMsgSteamNetworkingP2PRendezvous_ConnectRequest::_internal_to_virtual_port() const {
  return _impl_.to_virtual_port_;
}
inline uint32_t CMsgSteamNetworkingP2PRendezvous_ConnectRequest::to_virtual_port() const {
  // @@protoc_insertion_point(field_get:CMsgSteamNetworkingP2PRendezvous.ConnectRequest.to_virtual_port)
  return _internal_to_virtual_port();
}
inline void CMsgSteamNetworkingP2PRendezvous_ConnectRequest::_internal_set_to_virtual_port(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.to_virtual_port_ = value;
}
inline void CMsgSteamNetworkingP2PRendezvous_ConnectRequest::set_to_virtual_port(uint32_t value) {
  _internal_set_to_virtual_port(value);
  // @@protoc_insertion_point(field_set:CMsgSteamNetworkingP2PRendezvous.ConnectRequest.to_virtual_port)
}

// optional uint32 from_virtual_port = 10;
inline bool CMsgSteamNetworkingP2PRendezvous_ConnectRequest::_internal_has_from_virtual_port() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CMsgSteamNetworkingP2PRendezvous_ConnectRequest::has_from_virtual_port() const {
  return _internal_has_from_virtual_port();
}
inline void CMsgSteamNetworkingP2PRendezvous_ConnectRequest::clear_from_virtual_port() {
  _impl_.from_virtual_port_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline uint32_t CMsgSteamNetworkingP2PRendezvous_ConnectRequest::_internal_from_virtual_port() const {
  return _impl_.from_virtual_port_;
}
inline uint32_t CMsgSteamNetworkingP2PRendezvous_ConnectRequest::from_virtual_port() const {
  // @@protoc_insertion_point(field_get:CMsgSteamNetworkingP2PRendezvous.ConnectRequest.from_virtual_port)
  return _internal_from_virtual_port();
}
inline void CMsgSteamNetworkingP2PRendezvous_ConnectRequest::_internal_set_from_virtual_port(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.from_virtual_port_ = value;
}
inline void CMsgSteamNetworkingP2PRendezvous_ConnectRequest::set_from_virtual_port(uint32_t value) {
  _internal_set_from_virtual_port(value);
  // @@protoc_insertion_point(field_set:CMsgSteamNetworkingP2PRendezvous.ConnectRequest.from_virtual_port)
}

// optional string from_fakeip = 11;
inline bool CMsgSteamNetworkingP2PRendezvous_ConnectRequest::_internal_has_from_fakeip() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgSteamNetworkingP2PRendezvous_ConnectRequest::has_from_fakeip() const {
  return _internal_has_from_fakeip();
}
inline void CMsgSteamNetworkingP2PRendezvous_ConnectRequest::clear_from_fakeip() {
  _impl_.from_fakeip_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CMsgSteamNetworkingP2PRendezvous_ConnectRequest::from_fakeip() const {
  // @@protoc_insertion_point(field_get:CMsgSteamNetworkingP2PRendezvous.ConnectRequest.from_fakeip)
  return _internal_from_fakeip();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgSteamNetworkingP2PRendezvous_ConnectRequest::set_from_fakeip(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.from_fakeip_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgSteamNetworkingP2PRendezvous.ConnectRequest.from_fakeip)
}
inline std::string* CMsgSteamNetworkingP2PRendezvous_ConnectRequest::mutable_from_fakeip() {
  std::string* _s = _internal_mutable_from_fakeip();
  // @@protoc_insertion_point(field_mutable:CMsgSteamNetworkingP2PRendezvous.ConnectRequest.from_fakeip)
  return _s;
}
inline const std::string& CMsgSteamNetworkingP2PRendezvous_ConnectRequest::_internal_from_fakeip() const {
  return _impl_.from_fakeip_.Get();
}
inline void CMsgSteamNetworkingP2PRendezvous_ConnectRequest::_internal_set_from_fakeip(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.from_fakeip_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgSteamNetworkingP2PRendezvous_ConnectRequest::_internal_mutable_from_fakeip() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.from_fakeip_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgSteamNetworkingP2PRendezvous_ConnectRequest::release_from_fakeip() {
  // @@protoc_insertion_point(field_release:CMsgSteamNetworkingP2PRendezvous.ConnectRequest.from_fakeip)
  if (!_internal_has_from_fakeip()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.from_fakeip_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.from_fakeip_.IsDefault()) {
    _impl_.from_fakeip_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgSteamNetworkingP2PRendezvous_ConnectRequest::set_allocated_from_fakeip(std::string* from_fakeip) {
  if (from_fakeip != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.from_fakeip_.SetAllocated(from_fakeip, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.from_fakeip_.IsDefault()) {
    _impl_.from_fakeip_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamNetworkingP2PRendezvous.ConnectRequest.from_fakeip)
}

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

// CMsgSteamNetworkingP2PRendezvous_ConnectOK

// optional .CMsgSteamDatagramSessionCryptInfoSigned crypt = 5;
inline bool CMsgSteamNetworkingP2PRendezvous_ConnectOK::_internal_has_crypt() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.crypt_ != nullptr);
  return value;
}
inline bool CMsgSteamNetworkingP2PRendezvous_ConnectOK::has_crypt() const {
  return _internal_has_crypt();
}
inline void CMsgSteamNetworkingP2PRendezvous_ConnectOK::clear_crypt() {
  if (_impl_.crypt_ != nullptr) _impl_.crypt_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::CMsgSteamDatagramSessionCryptInfoSigned& CMsgSteamNetworkingP2PRendezvous_ConnectOK::_internal_crypt() const {
  const ::CMsgSteamDatagramSessionCryptInfoSigned* p = _impl_.crypt_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgSteamDatagramSessionCryptInfoSigned&>(
      ::_CMsgSteamDatagramSessionCryptInfoSigned_default_instance_);
}
inline const ::CMsgSteamDatagramSessionCryptInfoSigned& CMsgSteamNetworkingP2PRendezvous_ConnectOK::crypt() const {
  // @@protoc_insertion_point(field_get:CMsgSteamNetworkingP2PRendezvous.ConnectOK.crypt)
  return _internal_crypt();
}
inline void CMsgSteamNetworkingP2PRendezvous_ConnectOK::unsafe_arena_set_allocated_crypt(
    ::CMsgSteamDatagramSessionCryptInfoSigned* crypt) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.crypt_);
  }
  _impl_.crypt_ = crypt;
  if (crypt) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgSteamNetworkingP2PRendezvous.ConnectOK.crypt)
}
inline ::CMsgSteamDatagramSessionCryptInfoSigned* CMsgSteamNetworkingP2PRendezvous_ConnectOK::release_crypt() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgSteamDatagramSessionCryptInfoSigned* temp = _impl_.crypt_;
  _impl_.crypt_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::CMsgSteamDatagramSessionCryptInfoSigned* CMsgSteamNetworkingP2PRendezvous_ConnectOK::unsafe_arena_release_crypt() {
  // @@protoc_insertion_point(field_release:CMsgSteamNetworkingP2PRendezvous.ConnectOK.crypt)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgSteamDatagramSessionCryptInfoSigned* temp = _impl_.crypt_;
  _impl_.crypt_ = nullptr;
  return temp;
}
inline ::CMsgSteamDatagramSessionCryptInfoSigned* CMsgSteamNetworkingP2PRendezvous_ConnectOK::_internal_mutable_crypt() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.crypt_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgSteamDatagramSessionCryptInfoSigned>(GetArenaForAllocation());
    _impl_.crypt_ = p;
  }
  return _impl_.crypt_;
}
inline ::CMsgSteamDatagramSessionCryptInfoSigned* CMsgSteamNetworkingP2PRendezvous_ConnectOK::mutable_crypt() {
  ::CMsgSteamDatagramSessionCryptInfoSigned* _msg = _internal_mutable_crypt();
  // @@protoc_insertion_point(field_mutable:CMsgSteamNetworkingP2PRendezvous.ConnectOK.crypt)
  return _msg;
}
inline void CMsgSteamNetworkingP2PRendezvous_ConnectOK::set_allocated_crypt(::CMsgSteamDatagramSessionCryptInfoSigned* crypt) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.crypt_;
  }
  if (crypt) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(crypt);
    if (message_arena != submessage_arena) {
      crypt = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, crypt, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.crypt_ = crypt;
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamNetworkingP2PRendezvous.ConnectOK.crypt)
}

// optional .CMsgSteamDatagramCertificateSigned cert = 6;
inline bool CMsgSteamNetworkingP2PRendezvous_ConnectOK::_internal_has_cert() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.cert_ != nullptr);
  return value;
}
inline bool CMsgSteamNetworkingP2PRendezvous_ConnectOK::has_cert() const {
  return _internal_has_cert();
}
inline const ::CMsgSteamDatagramCertificateSigned& CMsgSteamNetworkingP2PRendezvous_ConnectOK::_internal_cert() const {
  const ::CMsgSteamDatagramCertificateSigned* p = _impl_.cert_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgSteamDatagramCertificateSigned&>(
      ::_CMsgSteamDatagramCertificateSigned_default_instance_);
}
inline const ::CMsgSteamDatagramCertificateSigned& CMsgSteamNetworkingP2PRendezvous_ConnectOK::cert() const {
  // @@protoc_insertion_point(field_get:CMsgSteamNetworkingP2PRendezvous.ConnectOK.cert)
  return _internal_cert();
}
inline void CMsgSteamNetworkingP2PRendezvous_ConnectOK::unsafe_arena_set_allocated_cert(
    ::CMsgSteamDatagramCertificateSigned* cert) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.cert_);
  }
  _impl_.cert_ = cert;
  if (cert) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgSteamNetworkingP2PRendezvous.ConnectOK.cert)
}
inline ::CMsgSteamDatagramCertificateSigned* CMsgSteamNetworkingP2PRendezvous_ConnectOK::release_cert() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgSteamDatagramCertificateSigned* temp = _impl_.cert_;
  _impl_.cert_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::CMsgSteamDatagramCertificateSigned* CMsgSteamNetworkingP2PRendezvous_ConnectOK::unsafe_arena_release_cert() {
  // @@protoc_insertion_point(field_release:CMsgSteamNetworkingP2PRendezvous.ConnectOK.cert)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgSteamDatagramCertificateSigned* temp = _impl_.cert_;
  _impl_.cert_ = nullptr;
  return temp;
}
inline ::CMsgSteamDatagramCertificateSigned* CMsgSteamNetworkingP2PRendezvous_ConnectOK::_internal_mutable_cert() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.cert_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgSteamDatagramCertificateSigned>(GetArenaForAllocation());
    _impl_.cert_ = p;
  }
  return _impl_.cert_;
}
inline ::CMsgSteamDatagramCertificateSigned* CMsgSteamNetworkingP2PRendezvous_ConnectOK::mutable_cert() {
  ::CMsgSteamDatagramCertificateSigned* _msg = _internal_mutable_cert();
  // @@protoc_insertion_point(field_mutable:CMsgSteamNetworkingP2PRendezvous.ConnectOK.cert)
  return _msg;
}
inline void CMsgSteamNetworkingP2PRendezvous_ConnectOK::set_allocated_cert(::CMsgSteamDatagramCertificateSigned* cert) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.cert_);
  }
  if (cert) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(cert));
    if (message_arena != submessage_arena) {
      cert = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, cert, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.cert_ = cert;
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamNetworkingP2PRendezvous.ConnectOK.cert)
}

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

// CMsgSteamNetworkingP2PRendezvous_ConnectionClosed

// optional string debug = 5;
inline bool CMsgSteamNetworkingP2PRendezvous_ConnectionClosed::_internal_has_debug() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgSteamNetworkingP2PRendezvous_ConnectionClosed::has_debug() const {
  return _internal_has_debug();
}
inline void CMsgSteamNetworkingP2PRendezvous_ConnectionClosed::clear_debug() {
  _impl_.debug_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CMsgSteamNetworkingP2PRendezvous_ConnectionClosed::debug() const {
  // @@protoc_insertion_point(field_get:CMsgSteamNetworkingP2PRendezvous.ConnectionClosed.debug)
  return _internal_debug();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgSteamNetworkingP2PRendezvous_ConnectionClosed::set_debug(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.debug_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgSteamNetworkingP2PRendezvous.ConnectionClosed.debug)
}
inline std::string* CMsgSteamNetworkingP2PRendezvous_ConnectionClosed::mutable_debug() {
  std::string* _s = _internal_mutable_debug();
  // @@protoc_insertion_point(field_mutable:CMsgSteamNetworkingP2PRendezvous.ConnectionClosed.debug)
  return _s;
}
inline const std::string& CMsgSteamNetworkingP2PRendezvous_ConnectionClosed::_internal_debug() const {
  return _impl_.debug_.Get();
}
inline void CMsgSteamNetworkingP2PRendezvous_ConnectionClosed::_internal_set_debug(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.debug_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgSteamNetworkingP2PRendezvous_ConnectionClosed::_internal_mutable_debug() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.debug_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgSteamNetworkingP2PRendezvous_ConnectionClosed::release_debug() {
  // @@protoc_insertion_point(field_release:CMsgSteamNetworkingP2PRendezvous.ConnectionClosed.debug)
  if (!_internal_has_debug()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.debug_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.debug_.IsDefault()) {
    _impl_.debug_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgSteamNetworkingP2PRendezvous_ConnectionClosed::set_allocated_debug(std::string* debug) {
  if (debug != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.debug_.SetAllocated(debug, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.debug_.IsDefault()) {
    _impl_.debug_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamNetworkingP2PRendezvous.ConnectionClosed.debug)
}

// optional uint32 reason_code = 6;
inline bool CMsgSteamNetworkingP2PRendezvous_ConnectionClosed::_internal_has_reason_code() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgSteamNetworkingP2PRendezvous_ConnectionClosed::has_reason_code() const {
  return _internal_has_reason_code();
}
inline void CMsgSteamNetworkingP2PRendezvous_ConnectionClosed::clear_reason_code() {
  _impl_.reason_code_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t CMsgSteamNetworkingP2PRendezvous_ConnectionClosed::_internal_reason_code() const {
  return _impl_.reason_code_;
}
inline uint32_t CMsgSteamNetworkingP2PRendezvous_ConnectionClosed::reason_code() const {
  // @@protoc_insertion_point(field_get:CMsgSteamNetworkingP2PRendezvous.ConnectionClosed.reason_code)
  return _internal_reason_code();
}
inline void CMsgSteamNetworkingP2PRendezvous_ConnectionClosed::_internal_set_reason_code(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.reason_code_ = value;
}
inline void CMsgSteamNetworkingP2PRendezvous_ConnectionClosed::set_reason_code(uint32_t value) {
  _internal_set_reason_code(value);
  // @@protoc_insertion_point(field_set:CMsgSteamNetworkingP2PRendezvous.ConnectionClosed.reason_code)
}

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

// CMsgSteamNetworkingP2PRendezvous_ReliableMessage

// optional .CMsgICERendezvous ice = 1;
inline bool CMsgSteamNetworkingP2PRendezvous_ReliableMessage::_internal_has_ice() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.ice_ != nullptr);
  return value;
}
inline bool CMsgSteamNetworkingP2PRendezvous_ReliableMessage::has_ice() const {
  return _internal_has_ice();
}
inline void CMsgSteamNetworkingP2PRendezvous_ReliableMessage::clear_ice() {
  if (_impl_.ice_ != nullptr) _impl_.ice_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::CMsgICERendezvous& CMsgSteamNetworkingP2PRendezvous_ReliableMessage::_internal_ice() const {
  const ::CMsgICERendezvous* p = _impl_.ice_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgICERendezvous&>(
      ::_CMsgICERendezvous_default_instance_);
}
inline const ::CMsgICERendezvous& CMsgSteamNetworkingP2PRendezvous_ReliableMessage::ice() const {
  // @@protoc_insertion_point(field_get:CMsgSteamNetworkingP2PRendezvous.ReliableMessage.ice)
  return _internal_ice();
}
inline void CMsgSteamNetworkingP2PRendezvous_ReliableMessage::unsafe_arena_set_allocated_ice(
    ::CMsgICERendezvous* ice) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.ice_);
  }
  _impl_.ice_ = ice;
  if (ice) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgSteamNetworkingP2PRendezvous.ReliableMessage.ice)
}
inline ::CMsgICERendezvous* CMsgSteamNetworkingP2PRendezvous_ReliableMessage::release_ice() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgICERendezvous* temp = _impl_.ice_;
  _impl_.ice_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::CMsgICERendezvous* CMsgSteamNetworkingP2PRendezvous_ReliableMessage::unsafe_arena_release_ice() {
  // @@protoc_insertion_point(field_release:CMsgSteamNetworkingP2PRendezvous.ReliableMessage.ice)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgICERendezvous* temp = _impl_.ice_;
  _impl_.ice_ = nullptr;
  return temp;
}
inline ::CMsgICERendezvous* CMsgSteamNetworkingP2PRendezvous_ReliableMessage::_internal_mutable_ice() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.ice_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgICERendezvous>(GetArenaForAllocation());
    _impl_.ice_ = p;
  }
  return _impl_.ice_;
}
inline ::CMsgICERendezvous* CMsgSteamNetworkingP2PRendezvous_ReliableMessage::mutable_ice() {
  ::CMsgICERendezvous* _msg = _internal_mutable_ice();
  // @@protoc_insertion_point(field_mutable:CMsgSteamNetworkingP2PRendezvous.ReliableMessage.ice)
  return _msg;
}
inline void CMsgSteamNetworkingP2PRendezvous_ReliableMessage::set_allocated_ice(::CMsgICERendezvous* ice) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.ice_;
  }
  if (ice) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(ice);
    if (message_arena != submessage_arena) {
      ice = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, ice, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.ice_ = ice;
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamNetworkingP2PRendezvous.ReliableMessage.ice)
}

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

// CMsgSteamNetworkingP2PRendezvous_ApplicationMessage

// optional bytes data = 1;
inline bool CMsgSteamNetworkingP2PRendezvous_ApplicationMessage::_internal_has_data() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgSteamNetworkingP2PRendezvous_ApplicationMessage::has_data() const {
  return _internal_has_data();
}
inline void CMsgSteamNetworkingP2PRendezvous_ApplicationMessage::clear_data() {
  _impl_.data_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CMsgSteamNetworkingP2PRendezvous_ApplicationMessage::data() const {
  // @@protoc_insertion_point(field_get:CMsgSteamNetworkingP2PRendezvous.ApplicationMessage.data)
  return _internal_data();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgSteamNetworkingP2PRendezvous_ApplicationMessage::set_data(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.data_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgSteamNetworkingP2PRendezvous.ApplicationMessage.data)
}
inline std::string* CMsgSteamNetworkingP2PRendezvous_ApplicationMessage::mutable_data() {
  std::string* _s = _internal_mutable_data();
  // @@protoc_insertion_point(field_mutable:CMsgSteamNetworkingP2PRendezvous.ApplicationMessage.data)
  return _s;
}
inline const std::string& CMsgSteamNetworkingP2PRendezvous_ApplicationMessage::_internal_data() const {
  return _impl_.data_.Get();
}
inline void CMsgSteamNetworkingP2PRendezvous_ApplicationMessage::_internal_set_data(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.data_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgSteamNetworkingP2PRendezvous_ApplicationMessage::_internal_mutable_data() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.data_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgSteamNetworkingP2PRendezvous_ApplicationMessage::release_data() {
  // @@protoc_insertion_point(field_release:CMsgSteamNetworkingP2PRendezvous.ApplicationMessage.data)
  if (!_internal_has_data()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.data_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.data_.IsDefault()) {
    _impl_.data_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgSteamNetworkingP2PRendezvous_ApplicationMessage::set_allocated_data(std::string* data) {
  if (data != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.data_.SetAllocated(data, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.data_.IsDefault()) {
    _impl_.data_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamNetworkingP2PRendezvous.ApplicationMessage.data)
}

// optional uint64 msg_num = 2;
inline bool CMsgSteamNetworkingP2PRendezvous_ApplicationMessage::_internal_has_msg_num() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgSteamNetworkingP2PRendezvous_ApplicationMessage::has_msg_num() const {
  return _internal_has_msg_num();
}
inline void CMsgSteamNetworkingP2PRendezvous_ApplicationMessage::clear_msg_num() {
  _impl_.msg_num_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint64_t CMsgSteamNetworkingP2PRendezvous_ApplicationMessage::_internal_msg_num() const {
  return _impl_.msg_num_;
}
inline uint64_t CMsgSteamNetworkingP2PRendezvous_ApplicationMessage::msg_num() const {
  // @@protoc_insertion_point(field_get:CMsgSteamNetworkingP2PRendezvous.ApplicationMessage.msg_num)
  return _internal_msg_num();
}
inline void CMsgSteamNetworkingP2PRendezvous_ApplicationMessage::_internal_set_msg_num(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.msg_num_ = value;
}
inline void CMsgSteamNetworkingP2PRendezvous_ApplicationMessage::set_msg_num(uint64_t value) {
  _internal_set_msg_num(value);
  // @@protoc_insertion_point(field_set:CMsgSteamNetworkingP2PRendezvous.ApplicationMessage.msg_num)
}

// optional uint32 flags = 3;
inline bool CMsgSteamNetworkingP2PRendezvous_ApplicationMessage::_internal_has_flags() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgSteamNetworkingP2PRendezvous_ApplicationMessage::has_flags() const {
  return _internal_has_flags();
}
inline void CMsgSteamNetworkingP2PRendezvous_ApplicationMessage::clear_flags() {
  _impl_.flags_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t CMsgSteamNetworkingP2PRendezvous_ApplicationMessage::_internal_flags() const {
  return _impl_.flags_;
}
inline uint32_t CMsgSteamNetworkingP2PRendezvous_ApplicationMessage::flags() const {
  // @@protoc_insertion_point(field_get:CMsgSteamNetworkingP2PRendezvous.ApplicationMessage.flags)
  return _internal_flags();
}
inline void CMsgSteamNetworkingP2PRendezvous_ApplicationMessage::_internal_set_flags(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.flags_ = value;
}
inline void CMsgSteamNetworkingP2PRendezvous_ApplicationMessage::set_flags(uint32_t value) {
  _internal_set_flags(value);
  // @@protoc_insertion_point(field_set:CMsgSteamNetworkingP2PRendezvous.ApplicationMessage.flags)
}

// optional uint32 lane_idx = 4;
inline bool CMsgSteamNetworkingP2PRendezvous_ApplicationMessage::_internal_has_lane_idx() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CMsgSteamNetworkingP2PRendezvous_ApplicationMessage::has_lane_idx() const {
  return _internal_has_lane_idx();
}
inline void CMsgSteamNetworkingP2PRendezvous_ApplicationMessage::clear_lane_idx() {
  _impl_.lane_idx_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t CMsgSteamNetworkingP2PRendezvous_ApplicationMessage::_internal_lane_idx() const {
  return _impl_.lane_idx_;
}
inline uint32_t CMsgSteamNetworkingP2PRendezvous_ApplicationMessage::lane_idx() const {
  // @@protoc_insertion_point(field_get:CMsgSteamNetworkingP2PRendezvous.ApplicationMessage.lane_idx)
  return _internal_lane_idx();
}
inline void CMsgSteamNetworkingP2PRendezvous_ApplicationMessage::_internal_set_lane_idx(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.lane_idx_ = value;
}
inline void CMsgSteamNetworkingP2PRendezvous_ApplicationMessage::set_lane_idx(uint32_t value) {
  _internal_set_lane_idx(value);
  // @@protoc_insertion_point(field_set:CMsgSteamNetworkingP2PRendezvous.ApplicationMessage.lane_idx)
}

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

// CMsgSteamNetworkingP2PRendezvous

// optional string from_identity = 8;
inline bool CMsgSteamNetworkingP2PRendezvous::_internal_has_from_identity() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgSteamNetworkingP2PRendezvous::has_from_identity() const {
  return _internal_has_from_identity();
}
inline void CMsgSteamNetworkingP2PRendezvous::clear_from_identity() {
  _impl_.from_identity_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& CMsgSteamNetworkingP2PRendezvous::from_identity() const {
  // @@protoc_insertion_point(field_get:CMsgSteamNetworkingP2PRendezvous.from_identity)
  return _internal_from_identity();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgSteamNetworkingP2PRendezvous::set_from_identity(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.from_identity_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgSteamNetworkingP2PRendezvous.from_identity)
}
inline std::string* CMsgSteamNetworkingP2PRendezvous::mutable_from_identity() {
  std::string* _s = _internal_mutable_from_identity();
  // @@protoc_insertion_point(field_mutable:CMsgSteamNetworkingP2PRendezvous.from_identity)
  return _s;
}
inline const std::string& CMsgSteamNetworkingP2PRendezvous::_internal_from_identity() const {
  return _impl_.from_identity_.Get();
}
inline void CMsgSteamNetworkingP2PRendezvous::_internal_set_from_identity(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.from_identity_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgSteamNetworkingP2PRendezvous::_internal_mutable_from_identity() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.from_identity_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgSteamNetworkingP2PRendezvous::release_from_identity() {
  // @@protoc_insertion_point(field_release:CMsgSteamNetworkingP2PRendezvous.from_identity)
  if (!_internal_has_from_identity()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.from_identity_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.from_identity_.IsDefault()) {
    _impl_.from_identity_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgSteamNetworkingP2PRendezvous::set_allocated_from_identity(std::string* from_identity) {
  if (from_identity != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.from_identity_.SetAllocated(from_identity, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.from_identity_.IsDefault()) {
    _impl_.from_identity_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamNetworkingP2PRendezvous.from_identity)
}

// optional fixed32 from_connection_id = 9;
inline bool CMsgSteamNetworkingP2PRendezvous::_internal_has_from_connection_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool CMsgSteamNetworkingP2PRendezvous::has_from_connection_id() const {
  return _internal_has_from_connection_id();
}
inline void CMsgSteamNetworkingP2PRendezvous::clear_from_connection_id() {
  _impl_.from_connection_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline uint32_t CMsgSteamNetworkingP2PRendezvous::_internal_from_connection_id() const {
  return _impl_.from_connection_id_;
}
inline uint32_t CMsgSteamNetworkingP2PRendezvous::from_connection_id() const {
  // @@protoc_insertion_point(field_get:CMsgSteamNetworkingP2PRendezvous.from_connection_id)
  return _internal_from_connection_id();
}
inline void CMsgSteamNetworkingP2PRendezvous::_internal_set_from_connection_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000400u;
  _impl_.from_connection_id_ = value;
}
inline void CMsgSteamNetworkingP2PRendezvous::set_from_connection_id(uint32_t value) {
  _internal_set_from_connection_id(value);
  // @@protoc_insertion_point(field_set:CMsgSteamNetworkingP2PRendezvous.from_connection_id)
}

// optional string to_identity = 10;
inline bool CMsgSteamNetworkingP2PRendezvous::_internal_has_to_identity() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgSteamNetworkingP2PRendezvous::has_to_identity() const {
  return _internal_has_to_identity();
}
inline void CMsgSteamNetworkingP2PRendezvous::clear_to_identity() {
  _impl_.to_identity_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& CMsgSteamNetworkingP2PRendezvous::to_identity() const {
  // @@protoc_insertion_point(field_get:CMsgSteamNetworkingP2PRendezvous.to_identity)
  return _internal_to_identity();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgSteamNetworkingP2PRendezvous::set_to_identity(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.to_identity_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgSteamNetworkingP2PRendezvous.to_identity)
}
inline std::string* CMsgSteamNetworkingP2PRendezvous::mutable_to_identity() {
  std::string* _s = _internal_mutable_to_identity();
  // @@protoc_insertion_point(field_mutable:CMsgSteamNetworkingP2PRendezvous.to_identity)
  return _s;
}
inline const std::string& CMsgSteamNetworkingP2PRendezvous::_internal_to_identity() const {
  return _impl_.to_identity_.Get();
}
inline void CMsgSteamNetworkingP2PRendezvous::_internal_set_to_identity(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.to_identity_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgSteamNetworkingP2PRendezvous::_internal_mutable_to_identity() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.to_identity_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgSteamNetworkingP2PRendezvous::release_to_identity() {
  // @@protoc_insertion_point(field_release:CMsgSteamNetworkingP2PRendezvous.to_identity)
  if (!_internal_has_to_identity()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* p = _impl_.to_identity_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.to_identity_.IsDefault()) {
    _impl_.to_identity_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgSteamNetworkingP2PRendezvous::set_allocated_to_identity(std::string* to_identity) {
  if (to_identity != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.to_identity_.SetAllocated(to_identity, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.to_identity_.IsDefault()) {
    _impl_.to_identity_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamNetworkingP2PRendezvous.to_identity)
}

// optional fixed32 to_connection_id = 1;
inline bool CMsgSteamNetworkingP2PRendezvous::_internal_has_to_connection_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool CMsgSteamNetworkingP2PRendezvous::has_to_connection_id() const {
  return _internal_has_to_connection_id();
}
inline void CMsgSteamNetworkingP2PRendezvous::clear_to_connection_id() {
  _impl_.to_connection_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline uint32_t CMsgSteamNetworkingP2PRendezvous::_internal_to_connection_id() const {
  return _impl_.to_connection_id_;
}
inline uint32_t CMsgSteamNetworkingP2PRendezvous::to_connection_id() const {
  // @@protoc_insertion_point(field_get:CMsgSteamNetworkingP2PRendezvous.to_connection_id)
  return _internal_to_connection_id();
}
inline void CMsgSteamNetworkingP2PRendezvous::_internal_set_to_connection_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.to_connection_id_ = value;
}
inline void CMsgSteamNetworkingP2PRendezvous::set_to_connection_id(uint32_t value) {
  _internal_set_to_connection_id(value);
  // @@protoc_insertion_point(field_set:CMsgSteamNetworkingP2PRendezvous.to_connection_id)
}

// optional bytes sdr_routes = 2;
inline bool CMsgSteamNetworkingP2PRendezvous::_internal_has_sdr_routes() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgSteamNetworkingP2PRendezvous::has_sdr_routes() const {
  return _internal_has_sdr_routes();
}
inline void CMsgSteamNetworkingP2PRendezvous::clear_sdr_routes() {
  _impl_.sdr_routes_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CMsgSteamNetworkingP2PRendezvous::sdr_routes() const {
  // @@protoc_insertion_point(field_get:CMsgSteamNetworkingP2PRendezvous.sdr_routes)
  return _internal_sdr_routes();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgSteamNetworkingP2PRendezvous::set_sdr_routes(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.sdr_routes_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgSteamNetworkingP2PRendezvous.sdr_routes)
}
inline std::string* CMsgSteamNetworkingP2PRendezvous::mutable_sdr_routes() {
  std::string* _s = _internal_mutable_sdr_routes();
  // @@protoc_insertion_point(field_mutable:CMsgSteamNetworkingP2PRendezvous.sdr_routes)
  return _s;
}
inline const std::string& CMsgSteamNetworkingP2PRendezvous::_internal_sdr_routes() const {
  return _impl_.sdr_routes_.Get();
}
inline void CMsgSteamNetworkingP2PRendezvous::_internal_set_sdr_routes(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.sdr_routes_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgSteamNetworkingP2PRendezvous::_internal_mutable_sdr_routes() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.sdr_routes_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgSteamNetworkingP2PRendezvous::release_sdr_routes() {
  // @@protoc_insertion_point(field_release:CMsgSteamNetworkingP2PRendezvous.sdr_routes)
  if (!_internal_has_sdr_routes()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.sdr_routes_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.sdr_routes_.IsDefault()) {
    _impl_.sdr_routes_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgSteamNetworkingP2PRendezvous::set_allocated_sdr_routes(std::string* sdr_routes) {
  if (sdr_routes != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.sdr_routes_.SetAllocated(sdr_routes, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.sdr_routes_.IsDefault()) {
    _impl_.sdr_routes_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamNetworkingP2PRendezvous.sdr_routes)
}

// optional uint32 ack_peer_routes_revision = 3;
inline bool CMsgSteamNetworkingP2PRendezvous::_internal_has_ack_peer_routes_revision() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool CMsgSteamNetworkingP2PRendezvous::has_ack_peer_routes_revision() const {
  return _internal_has_ack_peer_routes_revision();
}
inline void CMsgSteamNetworkingP2PRendezvous::clear_ack_peer_routes_revision() {
  _impl_.ack_peer_routes_revision_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline uint32_t CMsgSteamNetworkingP2PRendezvous::_internal_ack_peer_routes_revision() const {
  return _impl_.ack_peer_routes_revision_;
}
inline uint32_t CMsgSteamNetworkingP2PRendezvous::ack_peer_routes_revision() const {
  // @@protoc_insertion_point(field_get:CMsgSteamNetworkingP2PRendezvous.ack_peer_routes_revision)
  return _internal_ack_peer_routes_revision();
}
inline void CMsgSteamNetworkingP2PRendezvous::_internal_set_ack_peer_routes_revision(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.ack_peer_routes_revision_ = value;
}
inline void CMsgSteamNetworkingP2PRendezvous::set_ack_peer_routes_revision(uint32_t value) {
  _internal_set_ack_peer_routes_revision(value);
  // @@protoc_insertion_point(field_set:CMsgSteamNetworkingP2PRendezvous.ack_peer_routes_revision)
}

// optional bool ice_enabled = 7;
inline bool CMsgSteamNetworkingP2PRendezvous::_internal_has_ice_enabled() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool CMsgSteamNetworkingP2PRendezvous::has_ice_enabled() const {
  return _internal_has_ice_enabled();
}
inline void CMsgSteamNetworkingP2PRendezvous::clear_ice_enabled() {
  _impl_.ice_enabled_ = false;
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline bool CMsgSteamNetworkingP2PRendezvous::_internal_ice_enabled() const {
  return _impl_.ice_enabled_;
}
inline bool CMsgSteamNetworkingP2PRendezvous::ice_enabled() const {
  // @@protoc_insertion_point(field_get:CMsgSteamNetworkingP2PRendezvous.ice_enabled)
  return _internal_ice_enabled();
}
inline void CMsgSteamNetworkingP2PRendezvous::_internal_set_ice_enabled(bool value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.ice_enabled_ = value;
}
inline void CMsgSteamNetworkingP2PRendezvous::set_ice_enabled(bool value) {
  _internal_set_ice_enabled(value);
  // @@protoc_insertion_point(field_set:CMsgSteamNetworkingP2PRendezvous.ice_enabled)
}

// optional bytes hosted_server_ticket = 14;
inline bool CMsgSteamNetworkingP2PRendezvous::_internal_has_hosted_server_ticket() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CMsgSteamNetworkingP2PRendezvous::has_hosted_server_ticket() const {
  return _internal_has_hosted_server_ticket();
}
inline void CMsgSteamNetworkingP2PRendezvous::clear_hosted_server_ticket() {
  _impl_.hosted_server_ticket_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const std::string& CMsgSteamNetworkingP2PRendezvous::hosted_server_ticket() const {
  // @@protoc_insertion_point(field_get:CMsgSteamNetworkingP2PRendezvous.hosted_server_ticket)
  return _internal_hosted_server_ticket();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgSteamNetworkingP2PRendezvous::set_hosted_server_ticket(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000008u;
 _impl_.hosted_server_ticket_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgSteamNetworkingP2PRendezvous.hosted_server_ticket)
}
inline std::string* CMsgSteamNetworkingP2PRendezvous::mutable_hosted_server_ticket() {
  std::string* _s = _internal_mutable_hosted_server_ticket();
  // @@protoc_insertion_point(field_mutable:CMsgSteamNetworkingP2PRendezvous.hosted_server_ticket)
  return _s;
}
inline const std::string& CMsgSteamNetworkingP2PRendezvous::_internal_hosted_server_ticket() const {
  return _impl_.hosted_server_ticket_.Get();
}
inline void CMsgSteamNetworkingP2PRendezvous::_internal_set_hosted_server_ticket(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.hosted_server_ticket_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgSteamNetworkingP2PRendezvous::_internal_mutable_hosted_server_ticket() {
  _impl_._has_bits_[0] |= 0x00000008u;
  return _impl_.hosted_server_ticket_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgSteamNetworkingP2PRendezvous::release_hosted_server_ticket() {
  // @@protoc_insertion_point(field_release:CMsgSteamNetworkingP2PRendezvous.hosted_server_ticket)
  if (!_internal_has_hosted_server_ticket()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000008u;
  auto* p = _impl_.hosted_server_ticket_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.hosted_server_ticket_.IsDefault()) {
    _impl_.hosted_server_ticket_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgSteamNetworkingP2PRendezvous::set_allocated_hosted_server_ticket(std::string* hosted_server_ticket) {
  if (hosted_server_ticket != nullptr) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.hosted_server_ticket_.SetAllocated(hosted_server_ticket, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.hosted_server_ticket_.IsDefault()) {
    _impl_.hosted_server_ticket_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamNetworkingP2PRendezvous.hosted_server_ticket)
}

// optional .CMsgSteamNetworkingP2PRendezvous.ConnectRequest connect_request = 4;
inline bool CMsgSteamNetworkingP2PRendezvous::_internal_has_connect_request() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.connect_request_ != nullptr);
  return value;
}
inline bool CMsgSteamNetworkingP2PRendezvous::has_connect_request() const {
  return _internal_has_connect_request();
}
inline void CMsgSteamNetworkingP2PRendezvous::clear_connect_request() {
  if (_impl_.connect_request_ != nullptr) _impl_.connect_request_->Clear();
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline const ::CMsgSteamNetworkingP2PRendezvous_ConnectRequest& CMsgSteamNetworkingP2PRendezvous::_internal_connect_request() const {
  const ::CMsgSteamNetworkingP2PRendezvous_ConnectRequest* p = _impl_.connect_request_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgSteamNetworkingP2PRendezvous_ConnectRequest&>(
      ::_CMsgSteamNetworkingP2PRendezvous_ConnectRequest_default_instance_);
}
inline const ::CMsgSteamNetworkingP2PRendezvous_ConnectRequest& CMsgSteamNetworkingP2PRendezvous::connect_request() const {
  // @@protoc_insertion_point(field_get:CMsgSteamNetworkingP2PRendezvous.connect_request)
  return _internal_connect_request();
}
inline void CMsgSteamNetworkingP2PRendezvous::unsafe_arena_set_allocated_connect_request(
    ::CMsgSteamNetworkingP2PRendezvous_ConnectRequest* connect_request) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.connect_request_);
  }
  _impl_.connect_request_ = connect_request;
  if (connect_request) {
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgSteamNetworkingP2PRendezvous.connect_request)
}
inline ::CMsgSteamNetworkingP2PRendezvous_ConnectRequest* CMsgSteamNetworkingP2PRendezvous::release_connect_request() {
  _impl_._has_bits_[0] &= ~0x00000010u;
  ::CMsgSteamNetworkingP2PRendezvous_ConnectRequest* temp = _impl_.connect_request_;
  _impl_.connect_request_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::CMsgSteamNetworkingP2PRendezvous_ConnectRequest* CMsgSteamNetworkingP2PRendezvous::unsafe_arena_release_connect_request() {
  // @@protoc_insertion_point(field_release:CMsgSteamNetworkingP2PRendezvous.connect_request)
  _impl_._has_bits_[0] &= ~0x00000010u;
  ::CMsgSteamNetworkingP2PRendezvous_ConnectRequest* temp = _impl_.connect_request_;
  _impl_.connect_request_ = nullptr;
  return temp;
}
inline ::CMsgSteamNetworkingP2PRendezvous_ConnectRequest* CMsgSteamNetworkingP2PRendezvous::_internal_mutable_connect_request() {
  _impl_._has_bits_[0] |= 0x00000010u;
  if (_impl_.connect_request_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgSteamNetworkingP2PRendezvous_ConnectRequest>(GetArenaForAllocation());
    _impl_.connect_request_ = p;
  }
  return _impl_.connect_request_;
}
inline ::CMsgSteamNetworkingP2PRendezvous_ConnectRequest* CMsgSteamNetworkingP2PRendezvous::mutable_connect_request() {
  ::CMsgSteamNetworkingP2PRendezvous_ConnectRequest* _msg = _internal_mutable_connect_request();
  // @@protoc_insertion_point(field_mutable:CMsgSteamNetworkingP2PRendezvous.connect_request)
  return _msg;
}
inline void CMsgSteamNetworkingP2PRendezvous::set_allocated_connect_request(::CMsgSteamNetworkingP2PRendezvous_ConnectRequest* connect_request) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.connect_request_;
  }
  if (connect_request) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(connect_request);
    if (message_arena != submessage_arena) {
      connect_request = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, connect_request, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  _impl_.connect_request_ = connect_request;
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamNetworkingP2PRendezvous.connect_request)
}

// optional .CMsgSteamNetworkingP2PRendezvous.ConnectOK connect_ok = 5;
inline bool CMsgSteamNetworkingP2PRendezvous::_internal_has_connect_ok() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.connect_ok_ != nullptr);
  return value;
}
inline bool CMsgSteamNetworkingP2PRendezvous::has_connect_ok() const {
  return _internal_has_connect_ok();
}
inline void CMsgSteamNetworkingP2PRendezvous::clear_connect_ok() {
  if (_impl_.connect_ok_ != nullptr) _impl_.connect_ok_->Clear();
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline const ::CMsgSteamNetworkingP2PRendezvous_ConnectOK& CMsgSteamNetworkingP2PRendezvous::_internal_connect_ok() const {
  const ::CMsgSteamNetworkingP2PRendezvous_ConnectOK* p = _impl_.connect_ok_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgSteamNetworkingP2PRendezvous_ConnectOK&>(
      ::_CMsgSteamNetworkingP2PRendezvous_ConnectOK_default_instance_);
}
inline const ::CMsgSteamNetworkingP2PRendezvous_ConnectOK& CMsgSteamNetworkingP2PRendezvous::connect_ok() const {
  // @@protoc_insertion_point(field_get:CMsgSteamNetworkingP2PRendezvous.connect_ok)
  return _internal_connect_ok();
}
inline void CMsgSteamNetworkingP2PRendezvous::unsafe_arena_set_allocated_connect_ok(
    ::CMsgSteamNetworkingP2PRendezvous_ConnectOK* connect_ok) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.connect_ok_);
  }
  _impl_.connect_ok_ = connect_ok;
  if (connect_ok) {
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgSteamNetworkingP2PRendezvous.connect_ok)
}
inline ::CMsgSteamNetworkingP2PRendezvous_ConnectOK* CMsgSteamNetworkingP2PRendezvous::release_connect_ok() {
  _impl_._has_bits_[0] &= ~0x00000020u;
  ::CMsgSteamNetworkingP2PRendezvous_ConnectOK* temp = _impl_.connect_ok_;
  _impl_.connect_ok_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::CMsgSteamNetworkingP2PRendezvous_ConnectOK* CMsgSteamNetworkingP2PRendezvous::unsafe_arena_release_connect_ok() {
  // @@protoc_insertion_point(field_release:CMsgSteamNetworkingP2PRendezvous.connect_ok)
  _impl_._has_bits_[0] &= ~0x00000020u;
  ::CMsgSteamNetworkingP2PRendezvous_ConnectOK* temp = _impl_.connect_ok_;
  _impl_.connect_ok_ = nullptr;
  return temp;
}
inline ::CMsgSteamNetworkingP2PRendezvous_ConnectOK* CMsgSteamNetworkingP2PRendezvous::_internal_mutable_connect_ok() {
  _impl_._has_bits_[0] |= 0x00000020u;
  if (_impl_.connect_ok_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgSteamNetworkingP2PRendezvous_ConnectOK>(GetArenaForAllocation());
    _impl_.connect_ok_ = p;
  }
  return _impl_.connect_ok_;
}
inline ::CMsgSteamNetworkingP2PRendezvous_ConnectOK* CMsgSteamNetworkingP2PRendezvous::mutable_connect_ok() {
  ::CMsgSteamNetworkingP2PRendezvous_ConnectOK* _msg = _internal_mutable_connect_ok();
  // @@protoc_insertion_point(field_mutable:CMsgSteamNetworkingP2PRendezvous.connect_ok)
  return _msg;
}
inline void CMsgSteamNetworkingP2PRendezvous::set_allocated_connect_ok(::CMsgSteamNetworkingP2PRendezvous_ConnectOK* connect_ok) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.connect_ok_;
  }
  if (connect_ok) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(connect_ok);
    if (message_arena != submessage_arena) {
      connect_ok = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, connect_ok, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  _impl_.connect_ok_ = connect_ok;
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamNetworkingP2PRendezvous.connect_ok)
}

// optional .CMsgSteamNetworkingP2PRendezvous.ConnectionClosed connection_closed = 6;
inline bool CMsgSteamNetworkingP2PRendezvous::_internal_has_connection_closed() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.connection_closed_ != nullptr);
  return value;
}
inline bool CMsgSteamNetworkingP2PRendezvous::has_connection_closed() const {
  return _internal_has_connection_closed();
}
inline void CMsgSteamNetworkingP2PRendezvous::clear_connection_closed() {
  if (_impl_.connection_closed_ != nullptr) _impl_.connection_closed_->Clear();
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline const ::CMsgSteamNetworkingP2PRendezvous_ConnectionClosed& CMsgSteamNetworkingP2PRendezvous::_internal_connection_closed() const {
  const ::CMsgSteamNetworkingP2PRendezvous_ConnectionClosed* p = _impl_.connection_closed_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgSteamNetworkingP2PRendezvous_ConnectionClosed&>(
      ::_CMsgSteamNetworkingP2PRendezvous_ConnectionClosed_default_instance_);
}
inline const ::CMsgSteamNetworkingP2PRendezvous_ConnectionClosed& CMsgSteamNetworkingP2PRendezvous::connection_closed() const {
  // @@protoc_insertion_point(field_get:CMsgSteamNetworkingP2PRendezvous.connection_closed)
  return _internal_connection_closed();
}
inline void CMsgSteamNetworkingP2PRendezvous::unsafe_arena_set_allocated_connection_closed(
    ::CMsgSteamNetworkingP2PRendezvous_ConnectionClosed* connection_closed) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.connection_closed_);
  }
  _impl_.connection_closed_ = connection_closed;
  if (connection_closed) {
    _impl_._has_bits_[0] |= 0x00000040u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000040u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgSteamNetworkingP2PRendezvous.connection_closed)
}
inline ::CMsgSteamNetworkingP2PRendezvous_ConnectionClosed* CMsgSteamNetworkingP2PRendezvous::release_connection_closed() {
  _impl_._has_bits_[0] &= ~0x00000040u;
  ::CMsgSteamNetworkingP2PRendezvous_ConnectionClosed* temp = _impl_.connection_closed_;
  _impl_.connection_closed_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::CMsgSteamNetworkingP2PRendezvous_ConnectionClosed* CMsgSteamNetworkingP2PRendezvous::unsafe_arena_release_connection_closed() {
  // @@protoc_insertion_point(field_release:CMsgSteamNetworkingP2PRendezvous.connection_closed)
  _impl_._has_bits_[0] &= ~0x00000040u;
  ::CMsgSteamNetworkingP2PRendezvous_ConnectionClosed* temp = _impl_.connection_closed_;
  _impl_.connection_closed_ = nullptr;
  return temp;
}
inline ::CMsgSteamNetworkingP2PRendezvous_ConnectionClosed* CMsgSteamNetworkingP2PRendezvous::_internal_mutable_connection_closed() {
  _impl_._has_bits_[0] |= 0x00000040u;
  if (_impl_.connection_closed_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgSteamNetworkingP2PRendezvous_ConnectionClosed>(GetArenaForAllocation());
    _impl_.connection_closed_ = p;
  }
  return _impl_.connection_closed_;
}
inline ::CMsgSteamNetworkingP2PRendezvous_ConnectionClosed* CMsgSteamNetworkingP2PRendezvous::mutable_connection_closed() {
  ::CMsgSteamNetworkingP2PRendezvous_ConnectionClosed* _msg = _internal_mutable_connection_closed();
  // @@protoc_insertion_point(field_mutable:CMsgSteamNetworkingP2PRendezvous.connection_closed)
  return _msg;
}
inline void CMsgSteamNetworkingP2PRendezvous::set_allocated_connection_closed(::CMsgSteamNetworkingP2PRendezvous_ConnectionClosed* connection_closed) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.connection_closed_;
  }
  if (connection_closed) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(connection_closed);
    if (message_arena != submessage_arena) {
      connection_closed = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, connection_closed, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000040u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000040u;
  }
  _impl_.connection_closed_ = connection_closed;
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamNetworkingP2PRendezvous.connection_closed)
}

// optional uint32 ack_reliable_msg = 11;
inline bool CMsgSteamNetworkingP2PRendezvous::_internal_has_ack_reliable_msg() const {
  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
  return value;
}
inline bool CMsgSteamNetworkingP2PRendezvous::has_ack_reliable_msg() const {
  return _internal_has_ack_reliable_msg();
}
inline void CMsgSteamNetworkingP2PRendezvous::clear_ack_reliable_msg() {
  _impl_.ack_reliable_msg_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000800u;
}
inline uint32_t CMsgSteamNetworkingP2PRendezvous::_internal_ack_reliable_msg() const {
  return _impl_.ack_reliable_msg_;
}
inline uint32_t CMsgSteamNetworkingP2PRendezvous::ack_reliable_msg() const {
  // @@protoc_insertion_point(field_get:CMsgSteamNetworkingP2PRendezvous.ack_reliable_msg)
  return _internal_ack_reliable_msg();
}
inline void CMsgSteamNetworkingP2PRendezvous::_internal_set_ack_reliable_msg(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000800u;
  _impl_.ack_reliable_msg_ = value;
}
inline void CMsgSteamNetworkingP2PRendezvous::set_ack_reliable_msg(uint32_t value) {
  _internal_set_ack_reliable_msg(value);
  // @@protoc_insertion_point(field_set:CMsgSteamNetworkingP2PRendezvous.ack_reliable_msg)
}

// optional uint32 first_reliable_msg = 12;
inline bool CMsgSteamNetworkingP2PRendezvous::_internal_has_first_reliable_msg() const {
  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
  return value;
}
inline bool CMsgSteamNetworkingP2PRendezvous::has_first_reliable_msg() const {
  return _internal_has_first_reliable_msg();
}
inline void CMsgSteamNetworkingP2PRendezvous::clear_first_reliable_msg() {
  _impl_.first_reliable_msg_ = 0u;
  _impl_._has_bits_[0] &= ~0x00001000u;
}
inline uint32_t CMsgSteamNetworkingP2PRendezvous::_internal_first_reliable_msg() const {
  return _impl_.first_reliable_msg_;
}
inline uint32_t CMsgSteamNetworkingP2PRendezvous::first_reliable_msg() const {
  // @@protoc_insertion_point(field_get:CMsgSteamNetworkingP2PRendezvous.first_reliable_msg)
  return _internal_first_reliable_msg();
}
inline void CMsgSteamNetworkingP2PRendezvous::_internal_set_first_reliable_msg(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00001000u;
  _impl_.first_reliable_msg_ = value;
}
inline void CMsgSteamNetworkingP2PRendezvous::set_first_reliable_msg(uint32_t value) {
  _internal_set_first_reliable_msg(value);
  // @@protoc_insertion_point(field_set:CMsgSteamNetworkingP2PRendezvous.first_reliable_msg)
}

// repeated .CMsgSteamNetworkingP2PRendezvous.ReliableMessage reliable_messages = 13;
inline int CMsgSteamNetworkingP2PRendezvous::_internal_reliable_messages_size() const {
  return _impl_.reliable_messages_.size();
}
inline int CMsgSteamNetworkingP2PRendezvous::reliable_messages_size() const {
  return _internal_reliable_messages_size();
}
inline void CMsgSteamNetworkingP2PRendezvous::clear_reliable_messages() {
  _impl_.reliable_messages_.Clear();
}
inline ::CMsgSteamNetworkingP2PRendezvous_ReliableMessage* CMsgSteamNetworkingP2PRendezvous::mutable_reliable_messages(int index) {
  // @@protoc_insertion_point(field_mutable:CMsgSteamNetworkingP2PRendezvous.reliable_messages)
  return _impl_.reliable_messages_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgSteamNetworkingP2PRendezvous_ReliableMessage >*
CMsgSteamNetworkingP2PRendezvous::mutable_reliable_messages() {
  // @@protoc_insertion_point(field_mutable_list:CMsgSteamNetworkingP2PRendezvous.reliable_messages)
  return &_impl_.reliable_messages_;
}
inline const ::CMsgSteamNetworkingP2PRendezvous_ReliableMessage& CMsgSteamNetworkingP2PRendezvous::_internal_reliable_messages(int index) const {
  return _impl_.reliable_messages_.Get(index);
}
inline const ::CMsgSteamNetworkingP2PRendezvous_ReliableMessage& CMsgSteamNetworkingP2PRendezvous::reliable_messages(int index) const {
  // @@protoc_insertion_point(field_get:CMsgSteamNetworkingP2PRendezvous.reliable_messages)
  return _internal_reliable_messages(index);
}
inline ::CMsgSteamNetworkingP2PRendezvous_ReliableMessage* CMsgSteamNetworkingP2PRendezvous::_internal_add_reliable_messages() {
  return _impl_.reliable_messages_.Add();
}
inline ::CMsgSteamNetworkingP2PRendezvous_ReliableMessage* CMsgSteamNetworkingP2PRendezvous::add_reliable_messages() {
  ::CMsgSteamNetworkingP2PRendezvous_ReliableMessage* _add = _internal_add_reliable_messages();
  // @@protoc_insertion_point(field_add:CMsgSteamNetworkingP2PRendezvous.reliable_messages)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgSteamNetworkingP2PRendezvous_ReliableMessage >&
CMsgSteamNetworkingP2PRendezvous::reliable_messages() const {
  // @@protoc_insertion_point(field_list:CMsgSteamNetworkingP2PRendezvous.reliable_messages)
  return _impl_.reliable_messages_;
}

// repeated .CMsgSteamNetworkingP2PRendezvous.ApplicationMessage application_messages = 15;
inline int CMsgSteamNetworkingP2PRendezvous::_internal_application_messages_size() const {
  return _impl_.application_messages_.size();
}
inline int CMsgSteamNetworkingP2PRendezvous::application_messages_size() const {
  return _internal_application_messages_size();
}
inline void CMsgSteamNetworkingP2PRendezvous::clear_application_messages() {
  _impl_.application_messages_.Clear();
}
inline ::CMsgSteamNetworkingP2PRendezvous_ApplicationMessage* CMsgSteamNetworkingP2PRendezvous::mutable_application_messages(int index) {
  // @@protoc_insertion_point(field_mutable:CMsgSteamNetworkingP2PRendezvous.application_messages)
  return _impl_.application_messages_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgSteamNetworkingP2PRendezvous_ApplicationMessage >*
CMsgSteamNetworkingP2PRendezvous::mutable_application_messages() {
  // @@protoc_insertion_point(field_mutable_list:CMsgSteamNetworkingP2PRendezvous.application_messages)
  return &_impl_.application_messages_;
}
inline const ::CMsgSteamNetworkingP2PRendezvous_ApplicationMessage& CMsgSteamNetworkingP2PRendezvous::_internal_application_messages(int index) const {
  return _impl_.application_messages_.Get(index);
}
inline const ::CMsgSteamNetworkingP2PRendezvous_ApplicationMessage& CMsgSteamNetworkingP2PRendezvous::application_messages(int index) const {
  // @@protoc_insertion_point(field_get:CMsgSteamNetworkingP2PRendezvous.application_messages)
  return _internal_application_messages(index);
}
inline ::CMsgSteamNetworkingP2PRendezvous_ApplicationMessage* CMsgSteamNetworkingP2PRendezvous::_internal_add_application_messages() {
  return _impl_.application_messages_.Add();
}
inline ::CMsgSteamNetworkingP2PRendezvous_ApplicationMessage* CMsgSteamNetworkingP2PRendezvous::add_application_messages() {
  ::CMsgSteamNetworkingP2PRendezvous_ApplicationMessage* _add = _internal_add_application_messages();
  // @@protoc_insertion_point(field_add:CMsgSteamNetworkingP2PRendezvous.application_messages)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgSteamNetworkingP2PRendezvous_ApplicationMessage >&
CMsgSteamNetworkingP2PRendezvous::application_messages() const {
  // @@protoc_insertion_point(field_list:CMsgSteamNetworkingP2PRendezvous.application_messages)
  return _impl_.application_messages_;
}

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

// CMsgSteamNetworkingICESessionSummary

// optional uint32 failure_reason_code = 7;
inline bool CMsgSteamNetworkingICESessionSummary::_internal_has_failure_reason_code() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool CMsgSteamNetworkingICESessionSummary::has_failure_reason_code() const {
  return _internal_has_failure_reason_code();
}
inline void CMsgSteamNetworkingICESessionSummary::clear_failure_reason_code() {
  _impl_.failure_reason_code_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline uint32_t CMsgSteamNetworkingICESessionSummary::_internal_failure_reason_code() const {
  return _impl_.failure_reason_code_;
}
inline uint32_t CMsgSteamNetworkingICESessionSummary::failure_reason_code() const {
  // @@protoc_insertion_point(field_get:CMsgSteamNetworkingICESessionSummary.failure_reason_code)
  return _internal_failure_reason_code();
}
inline void CMsgSteamNetworkingICESessionSummary::_internal_set_failure_reason_code(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.failure_reason_code_ = value;
}
inline void CMsgSteamNetworkingICESessionSummary::set_failure_reason_code(uint32_t value) {
  _internal_set_failure_reason_code(value);
  // @@protoc_insertion_point(field_set:CMsgSteamNetworkingICESessionSummary.failure_reason_code)
}

// optional uint32 local_candidate_types = 1;
inline bool CMsgSteamNetworkingICESessionSummary::_internal_has_local_candidate_types() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgSteamNetworkingICESessionSummary::has_local_candidate_types() const {
  return _internal_has_local_candidate_types();
}
inline void CMsgSteamNetworkingICESessionSummary::clear_local_candidate_types() {
  _impl_.local_candidate_types_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t CMsgSteamNetworkingICESessionSummary::_internal_local_candidate_types() const {
  return _impl_.local_candidate_types_;
}
inline uint32_t CMsgSteamNetworkingICESessionSummary::local_candidate_types() const {
  // @@protoc_insertion_point(field_get:CMsgSteamNetworkingICESessionSummary.local_candidate_types)
  return _internal_local_candidate_types();
}
inline void CMsgSteamNetworkingICESessionSummary::_internal_set_local_candidate_types(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.local_candidate_types_ = value;
}
inline void CMsgSteamNetworkingICESessionSummary::set_local_candidate_types(uint32_t value) {
  _internal_set_local_candidate_types(value);
  // @@protoc_insertion_point(field_set:CMsgSteamNetworkingICESessionSummary.local_candidate_types)
}

// optional uint32 remote_candidate_types = 2;
inline bool CMsgSteamNetworkingICESessionSummary::_internal_has_remote_candidate_types() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgSteamNetworkingICESessionSummary::has_remote_candidate_types() const {
  return _internal_has_remote_candidate_types();
}
inline void CMsgSteamNetworkingICESessionSummary::clear_remote_candidate_types() {
  _impl_.remote_candidate_types_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t CMsgSteamNetworkingICESessionSummary::_internal_remote_candidate_types() const {
  return _impl_.remote_candidate_types_;
}
inline uint32_t CMsgSteamNetworkingICESessionSummary::remote_candidate_types() const {
  // @@protoc_insertion_point(field_get:CMsgSteamNetworkingICESessionSummary.remote_candidate_types)
  return _internal_remote_candidate_types();
}
inline void CMsgSteamNetworkingICESessionSummary::_internal_set_remote_candidate_types(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.remote_candidate_types_ = value;
}
inline void CMsgSteamNetworkingICESessionSummary::set_remote_candidate_types(uint32_t value) {
  _internal_set_remote_candidate_types(value);
  // @@protoc_insertion_point(field_set:CMsgSteamNetworkingICESessionSummary.remote_candidate_types)
}

// optional uint32 initial_route_kind = 3;
inline bool CMsgSteamNetworkingICESessionSummary::_internal_has_initial_route_kind() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgSteamNetworkingICESessionSummary::has_initial_route_kind() const {
  return _internal_has_initial_route_kind();
}
inline void CMsgSteamNetworkingICESessionSummary::clear_initial_route_kind() {
  _impl_.initial_route_kind_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t CMsgSteamNetworkingICESessionSummary::_internal_initial_route_kind() const {
  return _impl_.initial_route_kind_;
}
inline uint32_t CMsgSteamNetworkingICESessionSummary::initial_route_kind() const {
  // @@protoc_insertion_point(field_get:CMsgSteamNetworkingICESessionSummary.initial_route_kind)
  return _internal_initial_route_kind();
}
inline void CMsgSteamNetworkingICESessionSummary::_internal_set_initial_route_kind(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.initial_route_kind_ = value;
}
inline void CMsgSteamNetworkingICESessionSummary::set_initial_route_kind(uint32_t value) {
  _internal_set_initial_route_kind(value);
  // @@protoc_insertion_point(field_set:CMsgSteamNetworkingICESessionSummary.initial_route_kind)
}

// optional uint32 initial_ping = 4;
inline bool CMsgSteamNetworkingICESessionSummary::_internal_has_initial_ping() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CMsgSteamNetworkingICESessionSummary::has_initial_ping() const {
  return _internal_has_initial_ping();
}
inline void CMsgSteamNetworkingICESessionSummary::clear_initial_ping() {
  _impl_.initial_ping_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t CMsgSteamNetworkingICESessionSummary::_internal_initial_ping() const {
  return _impl_.initial_ping_;
}
inline uint32_t CMsgSteamNetworkingICESessionSummary::initial_ping() const {
  // @@protoc_insertion_point(field_get:CMsgSteamNetworkingICESessionSummary.initial_ping)
  return _internal_initial_ping();
}
inline void CMsgSteamNetworkingICESessionSummary::_internal_set_initial_ping(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.initial_ping_ = value;
}
inline void CMsgSteamNetworkingICESessionSummary::set_initial_ping(uint32_t value) {
  _internal_set_initial_ping(value);
  // @@protoc_insertion_point(field_set:CMsgSteamNetworkingICESessionSummary.initial_ping)
}

// optional uint32 initial_score = 6;
inline bool CMsgSteamNetworkingICESessionSummary::_internal_has_initial_score() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool CMsgSteamNetworkingICESessionSummary::has_initial_score() const {
  return _internal_has_initial_score();
}
inline void CMsgSteamNetworkingICESessionSummary::clear_initial_score() {
  _impl_.initial_score_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline uint32_t CMsgSteamNetworkingICESessionSummary::_internal_initial_score() const {
  return _impl_.initial_score_;
}
inline uint32_t CMsgSteamNetworkingICESessionSummary::initial_score() const {
  // @@protoc_insertion_point(field_get:CMsgSteamNetworkingICESessionSummary.initial_score)
  return _internal_initial_score();
}
inline void CMsgSteamNetworkingICESessionSummary::_internal_set_initial_score(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.initial_score_ = value;
}
inline void CMsgSteamNetworkingICESessionSummary::set_initial_score(uint32_t value) {
  _internal_set_initial_score(value);
  // @@protoc_insertion_point(field_set:CMsgSteamNetworkingICESessionSummary.initial_score)
}

// optional uint32 negotiation_ms = 5;
inline bool CMsgSteamNetworkingICESessionSummary::_internal_has_negotiation_ms() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CMsgSteamNetworkingICESessionSummary::has_negotiation_ms() const {
  return _internal_has_negotiation_ms();
}
inline void CMsgSteamNetworkingICESessionSummary::clear_negotiation_ms() {
  _impl_.negotiation_ms_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline uint32_t CMsgSteamNetworkingICESessionSummary::_internal_negotiation_ms() const {
  return _impl_.negotiation_ms_;
}
inline uint32_t CMsgSteamNetworkingICESessionSummary::negotiation_ms() const {
  // @@protoc_insertion_point(field_get:CMsgSteamNetworkingICESessionSummary.negotiation_ms)
  return _internal_negotiation_ms();
}
inline void CMsgSteamNetworkingICESessionSummary::_internal_set_negotiation_ms(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.negotiation_ms_ = value;
}
inline void CMsgSteamNetworkingICESessionSummary::set_negotiation_ms(uint32_t value) {
  _internal_set_negotiation_ms(value);
  // @@protoc_insertion_point(field_set:CMsgSteamNetworkingICESessionSummary.negotiation_ms)
}

// optional uint32 best_route_kind = 16;
inline bool CMsgSteamNetworkingICESessionSummary::_internal_has_best_route_kind() const {
  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
  return value;
}
inline bool CMsgSteamNetworkingICESessionSummary::has_best_route_kind() const {
  return _internal_has_best_route_kind();
}
inline void CMsgSteamNetworkingICESessionSummary::clear_best_route_kind() {
  _impl_.best_route_kind_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000800u;
}
inline uint32_t CMsgSteamNetworkingICESessionSummary::_internal_best_route_kind() const {
  return _impl_.best_route_kind_;
}
inline uint32_t CMsgSteamNetworkingICESessionSummary::best_route_kind() const {
  // @@protoc_insertion_point(field_get:CMsgSteamNetworkingICESessionSummary.best_route_kind)
  return _internal_best_route_kind();
}
inline void CMsgSteamNetworkingICESessionSummary::_internal_set_best_route_kind(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000800u;
  _impl_.best_route_kind_ = value;
}
inline void CMsgSteamNetworkingICESessionSummary::set_best_route_kind(uint32_t value) {
  _internal_set_best_route_kind(value);
  // @@protoc_insertion_point(field_set:CMsgSteamNetworkingICESessionSummary.best_route_kind)
}

// optional uint32 best_ping = 17;
inline bool CMsgSteamNetworkingICESessionSummary::_internal_has_best_ping() const {
  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
  return value;
}
inline bool CMsgSteamNetworkingICESessionSummary::has_best_ping() const {
  return _internal_has_best_ping();
}
inline void CMsgSteamNetworkingICESessionSummary::clear_best_ping() {
  _impl_.best_ping_ = 0u;
  _impl_._has_bits_[0] &= ~0x00001000u;
}
inline uint32_t CMsgSteamNetworkingICESessionSummary::_internal_best_ping() const {
  return _impl_.best_ping_;
}
inline uint32_t CMsgSteamNetworkingICESessionSummary::best_ping() const {
  // @@protoc_insertion_point(field_get:CMsgSteamNetworkingICESessionSummary.best_ping)
  return _internal_best_ping();
}
inline void CMsgSteamNetworkingICESessionSummary::_internal_set_best_ping(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00001000u;
  _impl_.best_ping_ = value;
}
inline void CMsgSteamNetworkingICESessionSummary::set_best_ping(uint32_t value) {
  _internal_set_best_ping(value);
  // @@protoc_insertion_point(field_set:CMsgSteamNetworkingICESessionSummary.best_ping)
}

// optional uint32 best_score = 18;
inline bool CMsgSteamNetworkingICESessionSummary::_internal_has_best_score() const {
  bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0;
  return value;
}
inline bool CMsgSteamNetworkingICESessionSummary::has_best_score() const {
  return _internal_has_best_score();
}
inline void CMsgSteamNetworkingICESessionSummary::clear_best_score() {
  _impl_.best_score_ = 0u;
  _impl_._has_bits_[0] &= ~0x00002000u;
}
inline uint32_t CMsgSteamNetworkingICESessionSummary::_internal_best_score() const {
  return _impl_.best_score_;
}
inline uint32_t CMsgSteamNetworkingICESessionSummary::best_score() const {
  // @@protoc_insertion_point(field_get:CMsgSteamNetworkingICESessionSummary.best_score)
  return _internal_best_score();
}
inline void CMsgSteamNetworkingICESessionSummary::_internal_set_best_score(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00002000u;
  _impl_.best_score_ = value;
}
inline void CMsgSteamNetworkingICESessionSummary::set_best_score(uint32_t value) {
  _internal_set_best_score(value);
  // @@protoc_insertion_point(field_set:CMsgSteamNetworkingICESessionSummary.best_score)
}

// optional uint32 best_time = 19;
inline bool CMsgSteamNetworkingICESessionSummary::_internal_has_best_time() const {
  bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0;
  return value;
}
inline bool CMsgSteamNetworkingICESessionSummary::has_best_time() const {
  return _internal_has_best_time();
}
inline void CMsgSteamNetworkingICESessionSummary::clear_best_time() {
  _impl_.best_time_ = 0u;
  _impl_._has_bits_[0] &= ~0x00004000u;
}
inline uint32_t CMsgSteamNetworkingICESessionSummary::_internal_best_time() const {
  return _impl_.best_time_;
}
inline uint32_t CMsgSteamNetworkingICESessionSummary::best_time() const {
  // @@protoc_insertion_point(field_get:CMsgSteamNetworkingICESessionSummary.best_time)
  return _internal_best_time();
}
inline void CMsgSteamNetworkingICESessionSummary::_internal_set_best_time(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00004000u;
  _impl_.best_time_ = value;
}
inline void CMsgSteamNetworkingICESessionSummary::set_best_time(uint32_t value) {
  _internal_set_best_time(value);
  // @@protoc_insertion_point(field_set:CMsgSteamNetworkingICESessionSummary.best_time)
}

// optional uint32 selected_seconds = 12;
inline bool CMsgSteamNetworkingICESessionSummary::_internal_has_selected_seconds() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool CMsgSteamNetworkingICESessionSummary::has_selected_seconds() const {
  return _internal_has_selected_seconds();
}
inline void CMsgSteamNetworkingICESessionSummary::clear_selected_seconds() {
  _impl_.selected_seconds_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline uint32_t CMsgSteamNetworkingICESessionSummary::_internal_selected_seconds() const {
  return _impl_.selected_seconds_;
}
inline uint32_t CMsgSteamNetworkingICESessionSummary::selected_seconds() const {
  // @@protoc_insertion_point(field_get:CMsgSteamNetworkingICESessionSummary.selected_seconds)
  return _internal_selected_seconds();
}
inline void CMsgSteamNetworkingICESessionSummary::_internal_set_selected_seconds(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.selected_seconds_ = value;
}
inline void CMsgSteamNetworkingICESessionSummary::set_selected_seconds(uint32_t value) {
  _internal_set_selected_seconds(value);
  // @@protoc_insertion_point(field_set:CMsgSteamNetworkingICESessionSummary.selected_seconds)
}

// optional uint32 user_settings = 13;
inline bool CMsgSteamNetworkingICESessionSummary::_internal_has_user_settings() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool CMsgSteamNetworkingICESessionSummary::has_user_settings() const {
  return _internal_has_user_settings();
}
inline void CMsgSteamNetworkingICESessionSummary::clear_user_settings() {
  _impl_.user_settings_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline uint32_t CMsgSteamNetworkingICESessionSummary::_internal_user_settings() const {
  return _impl_.user_settings_;
}
inline uint32_t CMsgSteamNetworkingICESessionSummary::user_settings() const {
  // @@protoc_insertion_point(field_get:CMsgSteamNetworkingICESessionSummary.user_settings)
  return _internal_user_settings();
}
inline void CMsgSteamNetworkingICESessionSummary::_internal_set_user_settings(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.user_settings_ = value;
}
inline void CMsgSteamNetworkingICESessionSummary::set_user_settings(uint32_t value) {
  _internal_set_user_settings(value);
  // @@protoc_insertion_point(field_set:CMsgSteamNetworkingICESessionSummary.user_settings)
}

// optional uint32 ice_enable_var = 14;
inline bool CMsgSteamNetworkingICESessionSummary::_internal_has_ice_enable_var() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool CMsgSteamNetworkingICESessionSummary::has_ice_enable_var() const {
  return _internal_has_ice_enable_var();
}
inline void CMsgSteamNetworkingICESessionSummary::clear_ice_enable_var() {
  _impl_.ice_enable_var_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline uint32_t CMsgSteamNetworkingICESessionSummary::_internal_ice_enable_var() const {
  return _impl_.ice_enable_var_;
}
inline uint32_t CMsgSteamNetworkingICESessionSummary::ice_enable_var() const {
  // @@protoc_insertion_point(field_get:CMsgSteamNetworkingICESessionSummary.ice_enable_var)
  return _internal_ice_enable_var();
}
inline void CMsgSteamNetworkingICESessionSummary::_internal_set_ice_enable_var(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.ice_enable_var_ = value;
}
inline void CMsgSteamNetworkingICESessionSummary::set_ice_enable_var(uint32_t value) {
  _internal_set_ice_enable_var(value);
  // @@protoc_insertion_point(field_set:CMsgSteamNetworkingICESessionSummary.ice_enable_var)
}

// optional uint32 local_candidate_types_allowed = 15;
inline bool CMsgSteamNetworkingICESessionSummary::_internal_has_local_candidate_types_allowed() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool CMsgSteamNetworkingICESessionSummary::has_local_candidate_types_allowed() const {
  return _internal_has_local_candidate_types_allowed();
}
inline void CMsgSteamNetworkingICESessionSummary::clear_local_candidate_types_allowed() {
  _impl_.local_candidate_types_allowed_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline uint32_t CMsgSteamNetworkingICESessionSummary::_internal_local_candidate_types_allowed() const {
  return _impl_.local_candidate_types_allowed_;
}
inline uint32_t CMsgSteamNetworkingICESessionSummary::local_candidate_types_allowed() const {
  // @@protoc_insertion_point(field_get:CMsgSteamNetworkingICESessionSummary.local_candidate_types_allowed)
  return _internal_local_candidate_types_allowed();
}
inline void CMsgSteamNetworkingICESessionSummary::_internal_set_local_candidate_types_allowed(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000400u;
  _impl_.local_candidate_types_allowed_ = value;
}
inline void CMsgSteamNetworkingICESessionSummary::set_local_candidate_types_allowed(uint32_t value) {
  _internal_set_local_candidate_types_allowed(value);
  // @@protoc_insertion_point(field_set:CMsgSteamNetworkingICESessionSummary.local_candidate_types_allowed)
}

#ifdef __GNUC__
  #pragma GCC diagnostic pop
#endif  // __GNUC__
// -------------------------------------------------------------------

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

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

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

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

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

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

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

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

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

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)


PROTOBUF_NAMESPACE_OPEN

template <> struct is_proto_enum< ::CMsgSteamDatagramSessionCryptInfo_EKeyType> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::CMsgSteamDatagramSessionCryptInfo_EKeyType>() {
  return ::CMsgSteamDatagramSessionCryptInfo_EKeyType_descriptor();
}
template <> struct is_proto_enum< ::ESteamNetworkingSocketsCipher> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::ESteamNetworkingSocketsCipher>() {
  return ::ESteamNetworkingSocketsCipher_descriptor();
}

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

#include <google/protobuf/port_undef.inc>
#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_steamnetworkingsockets_5fmessages_2eproto
