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

#ifndef GOOGLE_PROTOBUF_INCLUDED_steamdatagram_5fmessages_5fsdr_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_steamdatagram_5fmessages_5fsdr_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"
#include "steamnetworkingsockets_messages.pb.h"
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_steamdatagram_5fmessages_5fsdr_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_steamdatagram_5fmessages_5fsdr_2eproto {
  static const uint32_t offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_steamdatagram_5fmessages_5fsdr_2eproto;
class CMsgSteamDatagramClientPingSampleReply;
struct CMsgSteamDatagramClientPingSampleReplyDefaultTypeInternal;
extern CMsgSteamDatagramClientPingSampleReplyDefaultTypeInternal _CMsgSteamDatagramClientPingSampleReply_default_instance_;
class CMsgSteamDatagramClientPingSampleReply_LegacyDataCenter;
struct CMsgSteamDatagramClientPingSampleReply_LegacyDataCenterDefaultTypeInternal;
extern CMsgSteamDatagramClientPingSampleReply_LegacyDataCenterDefaultTypeInternal _CMsgSteamDatagramClientPingSampleReply_LegacyDataCenter_default_instance_;
class CMsgSteamDatagramClientPingSampleReply_POP;
struct CMsgSteamDatagramClientPingSampleReply_POPDefaultTypeInternal;
extern CMsgSteamDatagramClientPingSampleReply_POPDefaultTypeInternal _CMsgSteamDatagramClientPingSampleReply_POP_default_instance_;
class CMsgSteamDatagramClientPingSampleReply_POP_AltAddress;
struct CMsgSteamDatagramClientPingSampleReply_POP_AltAddressDefaultTypeInternal;
extern CMsgSteamDatagramClientPingSampleReply_POP_AltAddressDefaultTypeInternal _CMsgSteamDatagramClientPingSampleReply_POP_AltAddress_default_instance_;
class CMsgSteamDatagramClientPingSampleRequest;
struct CMsgSteamDatagramClientPingSampleRequestDefaultTypeInternal;
extern CMsgSteamDatagramClientPingSampleRequestDefaultTypeInternal _CMsgSteamDatagramClientPingSampleRequest_default_instance_;
class CMsgSteamDatagramClientSwitchedPrimary;
struct CMsgSteamDatagramClientSwitchedPrimaryDefaultTypeInternal;
extern CMsgSteamDatagramClientSwitchedPrimaryDefaultTypeInternal _CMsgSteamDatagramClientSwitchedPrimary_default_instance_;
class CMsgSteamDatagramClientSwitchedPrimary_RouterQuality;
struct CMsgSteamDatagramClientSwitchedPrimary_RouterQualityDefaultTypeInternal;
extern CMsgSteamDatagramClientSwitchedPrimary_RouterQualityDefaultTypeInternal _CMsgSteamDatagramClientSwitchedPrimary_RouterQuality_default_instance_;
class CMsgSteamDatagramConnectOK;
struct CMsgSteamDatagramConnectOKDefaultTypeInternal;
extern CMsgSteamDatagramConnectOKDefaultTypeInternal _CMsgSteamDatagramConnectOK_default_instance_;
class CMsgSteamDatagramConnectRequest;
struct CMsgSteamDatagramConnectRequestDefaultTypeInternal;
extern CMsgSteamDatagramConnectRequestDefaultTypeInternal _CMsgSteamDatagramConnectRequest_default_instance_;
class CMsgSteamDatagramConnectionClosed;
struct CMsgSteamDatagramConnectionClosedDefaultTypeInternal;
extern CMsgSteamDatagramConnectionClosedDefaultTypeInternal _CMsgSteamDatagramConnectionClosed_default_instance_;
class CMsgSteamDatagramConnectionStatsClientToRouter;
struct CMsgSteamDatagramConnectionStatsClientToRouterDefaultTypeInternal;
extern CMsgSteamDatagramConnectionStatsClientToRouterDefaultTypeInternal _CMsgSteamDatagramConnectionStatsClientToRouter_default_instance_;
class CMsgSteamDatagramConnectionStatsP2PClientToRouter;
struct CMsgSteamDatagramConnectionStatsP2PClientToRouterDefaultTypeInternal;
extern CMsgSteamDatagramConnectionStatsP2PClientToRouterDefaultTypeInternal _CMsgSteamDatagramConnectionStatsP2PClientToRouter_default_instance_;
class CMsgSteamDatagramConnectionStatsP2PRouterToClient;
struct CMsgSteamDatagramConnectionStatsP2PRouterToClientDefaultTypeInternal;
extern CMsgSteamDatagramConnectionStatsP2PRouterToClientDefaultTypeInternal _CMsgSteamDatagramConnectionStatsP2PRouterToClient_default_instance_;
class CMsgSteamDatagramConnectionStatsRouterToClient;
struct CMsgSteamDatagramConnectionStatsRouterToClientDefaultTypeInternal;
extern CMsgSteamDatagramConnectionStatsRouterToClientDefaultTypeInternal _CMsgSteamDatagramConnectionStatsRouterToClient_default_instance_;
class CMsgSteamDatagramConnectionStatsRouterToServer;
struct CMsgSteamDatagramConnectionStatsRouterToServerDefaultTypeInternal;
extern CMsgSteamDatagramConnectionStatsRouterToServerDefaultTypeInternal _CMsgSteamDatagramConnectionStatsRouterToServer_default_instance_;
class CMsgSteamDatagramConnectionStatsServerToRouter;
struct CMsgSteamDatagramConnectionStatsServerToRouterDefaultTypeInternal;
extern CMsgSteamDatagramConnectionStatsServerToRouterDefaultTypeInternal _CMsgSteamDatagramConnectionStatsServerToRouter_default_instance_;
class CMsgSteamDatagramGameserverPingReplyData;
struct CMsgSteamDatagramGameserverPingReplyDataDefaultTypeInternal;
extern CMsgSteamDatagramGameserverPingReplyDataDefaultTypeInternal _CMsgSteamDatagramGameserverPingReplyData_default_instance_;
class CMsgSteamDatagramGameserverPingRequestBody;
struct CMsgSteamDatagramGameserverPingRequestBodyDefaultTypeInternal;
extern CMsgSteamDatagramGameserverPingRequestBodyDefaultTypeInternal _CMsgSteamDatagramGameserverPingRequestBody_default_instance_;
class CMsgSteamDatagramGameserverPingRequestEnvelope;
struct CMsgSteamDatagramGameserverPingRequestEnvelopeDefaultTypeInternal;
extern CMsgSteamDatagramGameserverPingRequestEnvelopeDefaultTypeInternal _CMsgSteamDatagramGameserverPingRequestEnvelope_default_instance_;
class CMsgSteamDatagramGameserverSessionEstablished;
struct CMsgSteamDatagramGameserverSessionEstablishedDefaultTypeInternal;
extern CMsgSteamDatagramGameserverSessionEstablishedDefaultTypeInternal _CMsgSteamDatagramGameserverSessionEstablished_default_instance_;
class CMsgSteamDatagramGameserverSessionRequest;
struct CMsgSteamDatagramGameserverSessionRequestDefaultTypeInternal;
extern CMsgSteamDatagramGameserverSessionRequestDefaultTypeInternal _CMsgSteamDatagramGameserverSessionRequest_default_instance_;
class CMsgSteamDatagramNoConnection;
struct CMsgSteamDatagramNoConnectionDefaultTypeInternal;
extern CMsgSteamDatagramNoConnectionDefaultTypeInternal _CMsgSteamDatagramNoConnection_default_instance_;
class CMsgSteamDatagramNoSessionRelayToClient;
struct CMsgSteamDatagramNoSessionRelayToClientDefaultTypeInternal;
extern CMsgSteamDatagramNoSessionRelayToClientDefaultTypeInternal _CMsgSteamDatagramNoSessionRelayToClient_default_instance_;
class CMsgSteamDatagramNoSessionRelayToPeer;
struct CMsgSteamDatagramNoSessionRelayToPeerDefaultTypeInternal;
extern CMsgSteamDatagramNoSessionRelayToPeerDefaultTypeInternal _CMsgSteamDatagramNoSessionRelayToPeer_default_instance_;
class CMsgSteamDatagramP2PBadRouteRouterToClient;
struct CMsgSteamDatagramP2PBadRouteRouterToClientDefaultTypeInternal;
extern CMsgSteamDatagramP2PBadRouteRouterToClientDefaultTypeInternal _CMsgSteamDatagramP2PBadRouteRouterToClient_default_instance_;
class CMsgSteamDatagramP2PRoutes;
struct CMsgSteamDatagramP2PRoutesDefaultTypeInternal;
extern CMsgSteamDatagramP2PRoutesDefaultTypeInternal _CMsgSteamDatagramP2PRoutes_default_instance_;
class CMsgSteamDatagramP2PRoutes_RelayCluster;
struct CMsgSteamDatagramP2PRoutes_RelayClusterDefaultTypeInternal;
extern CMsgSteamDatagramP2PRoutes_RelayClusterDefaultTypeInternal _CMsgSteamDatagramP2PRoutes_RelayCluster_default_instance_;
class CMsgSteamDatagramP2PRoutes_Route;
struct CMsgSteamDatagramP2PRoutes_RouteDefaultTypeInternal;
extern CMsgSteamDatagramP2PRoutes_RouteDefaultTypeInternal _CMsgSteamDatagramP2PRoutes_Route_default_instance_;
class CMsgSteamDatagramP2PRoutingSummary;
struct CMsgSteamDatagramP2PRoutingSummaryDefaultTypeInternal;
extern CMsgSteamDatagramP2PRoutingSummaryDefaultTypeInternal _CMsgSteamDatagramP2PRoutingSummary_default_instance_;
class CMsgSteamDatagramP2PSessionEstablished;
struct CMsgSteamDatagramP2PSessionEstablishedDefaultTypeInternal;
extern CMsgSteamDatagramP2PSessionEstablishedDefaultTypeInternal _CMsgSteamDatagramP2PSessionEstablished_default_instance_;
class CMsgSteamDatagramP2PSessionRequest;
struct CMsgSteamDatagramP2PSessionRequestDefaultTypeInternal;
extern CMsgSteamDatagramP2PSessionRequestDefaultTypeInternal _CMsgSteamDatagramP2PSessionRequest_default_instance_;
class CMsgSteamDatagramP2PSessionRequestBody;
struct CMsgSteamDatagramP2PSessionRequestBodyDefaultTypeInternal;
extern CMsgSteamDatagramP2PSessionRequestBodyDefaultTypeInternal _CMsgSteamDatagramP2PSessionRequestBody_default_instance_;
class CMsgSteamDatagramP2PSessionRequestBody_EncryptedData;
struct CMsgSteamDatagramP2PSessionRequestBody_EncryptedDataDefaultTypeInternal;
extern CMsgSteamDatagramP2PSessionRequestBody_EncryptedDataDefaultTypeInternal _CMsgSteamDatagramP2PSessionRequestBody_EncryptedData_default_instance_;
class CMsgSteamDatagramRouterPingReply;
struct CMsgSteamDatagramRouterPingReplyDefaultTypeInternal;
extern CMsgSteamDatagramRouterPingReplyDefaultTypeInternal _CMsgSteamDatagramRouterPingReply_default_instance_;
class CMsgSteamDatagramRouterPingReply_AltAddress;
struct CMsgSteamDatagramRouterPingReply_AltAddressDefaultTypeInternal;
extern CMsgSteamDatagramRouterPingReply_AltAddressDefaultTypeInternal _CMsgSteamDatagramRouterPingReply_AltAddress_default_instance_;
class CMsgSteamDatagramRouterPingReply_RouteException;
struct CMsgSteamDatagramRouterPingReply_RouteExceptionDefaultTypeInternal;
extern CMsgSteamDatagramRouterPingReply_RouteExceptionDefaultTypeInternal _CMsgSteamDatagramRouterPingReply_RouteException_default_instance_;
class CMsgSteamDatagramSetSecondaryAddressRequest;
struct CMsgSteamDatagramSetSecondaryAddressRequestDefaultTypeInternal;
extern CMsgSteamDatagramSetSecondaryAddressRequestDefaultTypeInternal _CMsgSteamDatagramSetSecondaryAddressRequest_default_instance_;
class CMsgSteamDatagramSetSecondaryAddressResult;
struct CMsgSteamDatagramSetSecondaryAddressResultDefaultTypeInternal;
extern CMsgSteamDatagramSetSecondaryAddressResultDefaultTypeInternal _CMsgSteamDatagramSetSecondaryAddressResult_default_instance_;
class CMsgSteamDatagramSignedMessageGeneric;
struct CMsgSteamDatagramSignedMessageGenericDefaultTypeInternal;
extern CMsgSteamDatagramSignedMessageGenericDefaultTypeInternal _CMsgSteamDatagramSignedMessageGeneric_default_instance_;
class CMsgSteamNetworkingIPAddress;
struct CMsgSteamNetworkingIPAddressDefaultTypeInternal;
extern CMsgSteamNetworkingIPAddressDefaultTypeInternal _CMsgSteamNetworkingIPAddress_default_instance_;
class CMsgSteamNetworkingP2PSDRRoutingSummary;
struct CMsgSteamNetworkingP2PSDRRoutingSummaryDefaultTypeInternal;
extern CMsgSteamNetworkingP2PSDRRoutingSummaryDefaultTypeInternal _CMsgSteamNetworkingP2PSDRRoutingSummary_default_instance_;
class CMsgTOSTreatment;
struct CMsgTOSTreatmentDefaultTypeInternal;
extern CMsgTOSTreatmentDefaultTypeInternal _CMsgTOSTreatment_default_instance_;
PROTOBUF_NAMESPACE_OPEN
template<> ::CMsgSteamDatagramClientPingSampleReply* Arena::CreateMaybeMessage<::CMsgSteamDatagramClientPingSampleReply>(Arena*);
template<> ::CMsgSteamDatagramClientPingSampleReply_LegacyDataCenter* Arena::CreateMaybeMessage<::CMsgSteamDatagramClientPingSampleReply_LegacyDataCenter>(Arena*);
template<> ::CMsgSteamDatagramClientPingSampleReply_POP* Arena::CreateMaybeMessage<::CMsgSteamDatagramClientPingSampleReply_POP>(Arena*);
template<> ::CMsgSteamDatagramClientPingSampleReply_POP_AltAddress* Arena::CreateMaybeMessage<::CMsgSteamDatagramClientPingSampleReply_POP_AltAddress>(Arena*);
template<> ::CMsgSteamDatagramClientPingSampleRequest* Arena::CreateMaybeMessage<::CMsgSteamDatagramClientPingSampleRequest>(Arena*);
template<> ::CMsgSteamDatagramClientSwitchedPrimary* Arena::CreateMaybeMessage<::CMsgSteamDatagramClientSwitchedPrimary>(Arena*);
template<> ::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality* Arena::CreateMaybeMessage<::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality>(Arena*);
template<> ::CMsgSteamDatagramConnectOK* Arena::CreateMaybeMessage<::CMsgSteamDatagramConnectOK>(Arena*);
template<> ::CMsgSteamDatagramConnectRequest* Arena::CreateMaybeMessage<::CMsgSteamDatagramConnectRequest>(Arena*);
template<> ::CMsgSteamDatagramConnectionClosed* Arena::CreateMaybeMessage<::CMsgSteamDatagramConnectionClosed>(Arena*);
template<> ::CMsgSteamDatagramConnectionStatsClientToRouter* Arena::CreateMaybeMessage<::CMsgSteamDatagramConnectionStatsClientToRouter>(Arena*);
template<> ::CMsgSteamDatagramConnectionStatsP2PClientToRouter* Arena::CreateMaybeMessage<::CMsgSteamDatagramConnectionStatsP2PClientToRouter>(Arena*);
template<> ::CMsgSteamDatagramConnectionStatsP2PRouterToClient* Arena::CreateMaybeMessage<::CMsgSteamDatagramConnectionStatsP2PRouterToClient>(Arena*);
template<> ::CMsgSteamDatagramConnectionStatsRouterToClient* Arena::CreateMaybeMessage<::CMsgSteamDatagramConnectionStatsRouterToClient>(Arena*);
template<> ::CMsgSteamDatagramConnectionStatsRouterToServer* Arena::CreateMaybeMessage<::CMsgSteamDatagramConnectionStatsRouterToServer>(Arena*);
template<> ::CMsgSteamDatagramConnectionStatsServerToRouter* Arena::CreateMaybeMessage<::CMsgSteamDatagramConnectionStatsServerToRouter>(Arena*);
template<> ::CMsgSteamDatagramGameserverPingReplyData* Arena::CreateMaybeMessage<::CMsgSteamDatagramGameserverPingReplyData>(Arena*);
template<> ::CMsgSteamDatagramGameserverPingRequestBody* Arena::CreateMaybeMessage<::CMsgSteamDatagramGameserverPingRequestBody>(Arena*);
template<> ::CMsgSteamDatagramGameserverPingRequestEnvelope* Arena::CreateMaybeMessage<::CMsgSteamDatagramGameserverPingRequestEnvelope>(Arena*);
template<> ::CMsgSteamDatagramGameserverSessionEstablished* Arena::CreateMaybeMessage<::CMsgSteamDatagramGameserverSessionEstablished>(Arena*);
template<> ::CMsgSteamDatagramGameserverSessionRequest* Arena::CreateMaybeMessage<::CMsgSteamDatagramGameserverSessionRequest>(Arena*);
template<> ::CMsgSteamDatagramNoConnection* Arena::CreateMaybeMessage<::CMsgSteamDatagramNoConnection>(Arena*);
template<> ::CMsgSteamDatagramNoSessionRelayToClient* Arena::CreateMaybeMessage<::CMsgSteamDatagramNoSessionRelayToClient>(Arena*);
template<> ::CMsgSteamDatagramNoSessionRelayToPeer* Arena::CreateMaybeMessage<::CMsgSteamDatagramNoSessionRelayToPeer>(Arena*);
template<> ::CMsgSteamDatagramP2PBadRouteRouterToClient* Arena::CreateMaybeMessage<::CMsgSteamDatagramP2PBadRouteRouterToClient>(Arena*);
template<> ::CMsgSteamDatagramP2PRoutes* Arena::CreateMaybeMessage<::CMsgSteamDatagramP2PRoutes>(Arena*);
template<> ::CMsgSteamDatagramP2PRoutes_RelayCluster* Arena::CreateMaybeMessage<::CMsgSteamDatagramP2PRoutes_RelayCluster>(Arena*);
template<> ::CMsgSteamDatagramP2PRoutes_Route* Arena::CreateMaybeMessage<::CMsgSteamDatagramP2PRoutes_Route>(Arena*);
template<> ::CMsgSteamDatagramP2PRoutingSummary* Arena::CreateMaybeMessage<::CMsgSteamDatagramP2PRoutingSummary>(Arena*);
template<> ::CMsgSteamDatagramP2PSessionEstablished* Arena::CreateMaybeMessage<::CMsgSteamDatagramP2PSessionEstablished>(Arena*);
template<> ::CMsgSteamDatagramP2PSessionRequest* Arena::CreateMaybeMessage<::CMsgSteamDatagramP2PSessionRequest>(Arena*);
template<> ::CMsgSteamDatagramP2PSessionRequestBody* Arena::CreateMaybeMessage<::CMsgSteamDatagramP2PSessionRequestBody>(Arena*);
template<> ::CMsgSteamDatagramP2PSessionRequestBody_EncryptedData* Arena::CreateMaybeMessage<::CMsgSteamDatagramP2PSessionRequestBody_EncryptedData>(Arena*);
template<> ::CMsgSteamDatagramRouterPingReply* Arena::CreateMaybeMessage<::CMsgSteamDatagramRouterPingReply>(Arena*);
template<> ::CMsgSteamDatagramRouterPingReply_AltAddress* Arena::CreateMaybeMessage<::CMsgSteamDatagramRouterPingReply_AltAddress>(Arena*);
template<> ::CMsgSteamDatagramRouterPingReply_RouteException* Arena::CreateMaybeMessage<::CMsgSteamDatagramRouterPingReply_RouteException>(Arena*);
template<> ::CMsgSteamDatagramSetSecondaryAddressRequest* Arena::CreateMaybeMessage<::CMsgSteamDatagramSetSecondaryAddressRequest>(Arena*);
template<> ::CMsgSteamDatagramSetSecondaryAddressResult* Arena::CreateMaybeMessage<::CMsgSteamDatagramSetSecondaryAddressResult>(Arena*);
template<> ::CMsgSteamDatagramSignedMessageGeneric* Arena::CreateMaybeMessage<::CMsgSteamDatagramSignedMessageGeneric>(Arena*);
template<> ::CMsgSteamNetworkingIPAddress* Arena::CreateMaybeMessage<::CMsgSteamNetworkingIPAddress>(Arena*);
template<> ::CMsgSteamNetworkingP2PSDRRoutingSummary* Arena::CreateMaybeMessage<::CMsgSteamNetworkingP2PSDRRoutingSummary>(Arena*);
template<> ::CMsgTOSTreatment* Arena::CreateMaybeMessage<::CMsgTOSTreatment>(Arena*);
PROTOBUF_NAMESPACE_CLOSE

enum CMsgSteamDatagramRouterPingReply_AltAddress_Protocol : int {
  CMsgSteamDatagramRouterPingReply_AltAddress_Protocol_DefaultProtocol = 0
};
bool CMsgSteamDatagramRouterPingReply_AltAddress_Protocol_IsValid(int value);
constexpr CMsgSteamDatagramRouterPingReply_AltAddress_Protocol CMsgSteamDatagramRouterPingReply_AltAddress_Protocol_Protocol_MIN = CMsgSteamDatagramRouterPingReply_AltAddress_Protocol_DefaultProtocol;
constexpr CMsgSteamDatagramRouterPingReply_AltAddress_Protocol CMsgSteamDatagramRouterPingReply_AltAddress_Protocol_Protocol_MAX = CMsgSteamDatagramRouterPingReply_AltAddress_Protocol_DefaultProtocol;
constexpr int CMsgSteamDatagramRouterPingReply_AltAddress_Protocol_Protocol_ARRAYSIZE = CMsgSteamDatagramRouterPingReply_AltAddress_Protocol_Protocol_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* CMsgSteamDatagramRouterPingReply_AltAddress_Protocol_descriptor();
template<typename T>
inline const std::string& CMsgSteamDatagramRouterPingReply_AltAddress_Protocol_Name(T enum_t_value) {
  static_assert(::std::is_same<T, CMsgSteamDatagramRouterPingReply_AltAddress_Protocol>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function CMsgSteamDatagramRouterPingReply_AltAddress_Protocol_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    CMsgSteamDatagramRouterPingReply_AltAddress_Protocol_descriptor(), enum_t_value);
}
inline bool CMsgSteamDatagramRouterPingReply_AltAddress_Protocol_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, CMsgSteamDatagramRouterPingReply_AltAddress_Protocol* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<CMsgSteamDatagramRouterPingReply_AltAddress_Protocol>(
    CMsgSteamDatagramRouterPingReply_AltAddress_Protocol_descriptor(), name, value);
}
enum CMsgSteamDatagramRouterPingReply_Flags : int {
  CMsgSteamDatagramRouterPingReply_Flags_FLAG_MAYBE_MORE_DATA_CENTERS = 1,
  CMsgSteamDatagramRouterPingReply_Flags_FLAG_MAYBE_MORE_ALT_ADDRESSES = 2
};
bool CMsgSteamDatagramRouterPingReply_Flags_IsValid(int value);
constexpr CMsgSteamDatagramRouterPingReply_Flags CMsgSteamDatagramRouterPingReply_Flags_Flags_MIN = CMsgSteamDatagramRouterPingReply_Flags_FLAG_MAYBE_MORE_DATA_CENTERS;
constexpr CMsgSteamDatagramRouterPingReply_Flags CMsgSteamDatagramRouterPingReply_Flags_Flags_MAX = CMsgSteamDatagramRouterPingReply_Flags_FLAG_MAYBE_MORE_ALT_ADDRESSES;
constexpr int CMsgSteamDatagramRouterPingReply_Flags_Flags_ARRAYSIZE = CMsgSteamDatagramRouterPingReply_Flags_Flags_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* CMsgSteamDatagramRouterPingReply_Flags_descriptor();
template<typename T>
inline const std::string& CMsgSteamDatagramRouterPingReply_Flags_Name(T enum_t_value) {
  static_assert(::std::is_same<T, CMsgSteamDatagramRouterPingReply_Flags>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function CMsgSteamDatagramRouterPingReply_Flags_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    CMsgSteamDatagramRouterPingReply_Flags_descriptor(), enum_t_value);
}
inline bool CMsgSteamDatagramRouterPingReply_Flags_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, CMsgSteamDatagramRouterPingReply_Flags* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<CMsgSteamDatagramRouterPingReply_Flags>(
    CMsgSteamDatagramRouterPingReply_Flags_descriptor(), name, value);
}
enum CMsgSteamDatagramConnectionClosed_ERelayMode : int {
  CMsgSteamDatagramConnectionClosed_ERelayMode_None = 0,
  CMsgSteamDatagramConnectionClosed_ERelayMode_EndToEnd = 1,
  CMsgSteamDatagramConnectionClosed_ERelayMode_ClosedByPeer = 2
};
bool CMsgSteamDatagramConnectionClosed_ERelayMode_IsValid(int value);
constexpr CMsgSteamDatagramConnectionClosed_ERelayMode CMsgSteamDatagramConnectionClosed_ERelayMode_ERelayMode_MIN = CMsgSteamDatagramConnectionClosed_ERelayMode_None;
constexpr CMsgSteamDatagramConnectionClosed_ERelayMode CMsgSteamDatagramConnectionClosed_ERelayMode_ERelayMode_MAX = CMsgSteamDatagramConnectionClosed_ERelayMode_ClosedByPeer;
constexpr int CMsgSteamDatagramConnectionClosed_ERelayMode_ERelayMode_ARRAYSIZE = CMsgSteamDatagramConnectionClosed_ERelayMode_ERelayMode_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* CMsgSteamDatagramConnectionClosed_ERelayMode_descriptor();
template<typename T>
inline const std::string& CMsgSteamDatagramConnectionClosed_ERelayMode_Name(T enum_t_value) {
  static_assert(::std::is_same<T, CMsgSteamDatagramConnectionClosed_ERelayMode>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function CMsgSteamDatagramConnectionClosed_ERelayMode_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    CMsgSteamDatagramConnectionClosed_ERelayMode_descriptor(), enum_t_value);
}
inline bool CMsgSteamDatagramConnectionClosed_ERelayMode_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, CMsgSteamDatagramConnectionClosed_ERelayMode* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<CMsgSteamDatagramConnectionClosed_ERelayMode>(
    CMsgSteamDatagramConnectionClosed_ERelayMode_descriptor(), name, value);
}
enum CMsgSteamDatagramConnectionStatsClientToRouter_Flags : int {
  CMsgSteamDatagramConnectionStatsClientToRouter_Flags_ACK_REQUEST_RELAY = 1,
  CMsgSteamDatagramConnectionStatsClientToRouter_Flags_ACK_REQUEST_E2E = 2,
  CMsgSteamDatagramConnectionStatsClientToRouter_Flags_ACK_REQUEST_IMMEDIATE = 4,
  CMsgSteamDatagramConnectionStatsClientToRouter_Flags_NOT_PRIMARY_SESSION = 8,
  CMsgSteamDatagramConnectionStatsClientToRouter_Flags_CLIENT_RELAY_OVERRIDE = 32
};
bool CMsgSteamDatagramConnectionStatsClientToRouter_Flags_IsValid(int value);
constexpr CMsgSteamDatagramConnectionStatsClientToRouter_Flags CMsgSteamDatagramConnectionStatsClientToRouter_Flags_Flags_MIN = CMsgSteamDatagramConnectionStatsClientToRouter_Flags_ACK_REQUEST_RELAY;
constexpr CMsgSteamDatagramConnectionStatsClientToRouter_Flags CMsgSteamDatagramConnectionStatsClientToRouter_Flags_Flags_MAX = CMsgSteamDatagramConnectionStatsClientToRouter_Flags_CLIENT_RELAY_OVERRIDE;
constexpr int CMsgSteamDatagramConnectionStatsClientToRouter_Flags_Flags_ARRAYSIZE = CMsgSteamDatagramConnectionStatsClientToRouter_Flags_Flags_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* CMsgSteamDatagramConnectionStatsClientToRouter_Flags_descriptor();
template<typename T>
inline const std::string& CMsgSteamDatagramConnectionStatsClientToRouter_Flags_Name(T enum_t_value) {
  static_assert(::std::is_same<T, CMsgSteamDatagramConnectionStatsClientToRouter_Flags>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function CMsgSteamDatagramConnectionStatsClientToRouter_Flags_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    CMsgSteamDatagramConnectionStatsClientToRouter_Flags_descriptor(), enum_t_value);
}
inline bool CMsgSteamDatagramConnectionStatsClientToRouter_Flags_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, CMsgSteamDatagramConnectionStatsClientToRouter_Flags* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<CMsgSteamDatagramConnectionStatsClientToRouter_Flags>(
    CMsgSteamDatagramConnectionStatsClientToRouter_Flags_descriptor(), name, value);
}
enum CMsgSteamDatagramConnectionStatsRouterToClient_Flags : int {
  CMsgSteamDatagramConnectionStatsRouterToClient_Flags_ACK_REQUEST_RELAY = 1,
  CMsgSteamDatagramConnectionStatsRouterToClient_Flags_ACK_REQUEST_E2E = 2,
  CMsgSteamDatagramConnectionStatsRouterToClient_Flags_ACK_REQUEST_IMMEDIATE = 4
};
bool CMsgSteamDatagramConnectionStatsRouterToClient_Flags_IsValid(int value);
constexpr CMsgSteamDatagramConnectionStatsRouterToClient_Flags CMsgSteamDatagramConnectionStatsRouterToClient_Flags_Flags_MIN = CMsgSteamDatagramConnectionStatsRouterToClient_Flags_ACK_REQUEST_RELAY;
constexpr CMsgSteamDatagramConnectionStatsRouterToClient_Flags CMsgSteamDatagramConnectionStatsRouterToClient_Flags_Flags_MAX = CMsgSteamDatagramConnectionStatsRouterToClient_Flags_ACK_REQUEST_IMMEDIATE;
constexpr int CMsgSteamDatagramConnectionStatsRouterToClient_Flags_Flags_ARRAYSIZE = CMsgSteamDatagramConnectionStatsRouterToClient_Flags_Flags_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* CMsgSteamDatagramConnectionStatsRouterToClient_Flags_descriptor();
template<typename T>
inline const std::string& CMsgSteamDatagramConnectionStatsRouterToClient_Flags_Name(T enum_t_value) {
  static_assert(::std::is_same<T, CMsgSteamDatagramConnectionStatsRouterToClient_Flags>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function CMsgSteamDatagramConnectionStatsRouterToClient_Flags_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    CMsgSteamDatagramConnectionStatsRouterToClient_Flags_descriptor(), enum_t_value);
}
inline bool CMsgSteamDatagramConnectionStatsRouterToClient_Flags_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, CMsgSteamDatagramConnectionStatsRouterToClient_Flags* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<CMsgSteamDatagramConnectionStatsRouterToClient_Flags>(
    CMsgSteamDatagramConnectionStatsRouterToClient_Flags_descriptor(), name, value);
}
enum CMsgSteamDatagramConnectionStatsRouterToServer_Flags : int {
  CMsgSteamDatagramConnectionStatsRouterToServer_Flags_ACK_REQUEST_RELAY = 1,
  CMsgSteamDatagramConnectionStatsRouterToServer_Flags_ACK_REQUEST_E2E = 2,
  CMsgSteamDatagramConnectionStatsRouterToServer_Flags_ACK_REQUEST_IMMEDIATE = 4
};
bool CMsgSteamDatagramConnectionStatsRouterToServer_Flags_IsValid(int value);
constexpr CMsgSteamDatagramConnectionStatsRouterToServer_Flags CMsgSteamDatagramConnectionStatsRouterToServer_Flags_Flags_MIN = CMsgSteamDatagramConnectionStatsRouterToServer_Flags_ACK_REQUEST_RELAY;
constexpr CMsgSteamDatagramConnectionStatsRouterToServer_Flags CMsgSteamDatagramConnectionStatsRouterToServer_Flags_Flags_MAX = CMsgSteamDatagramConnectionStatsRouterToServer_Flags_ACK_REQUEST_IMMEDIATE;
constexpr int CMsgSteamDatagramConnectionStatsRouterToServer_Flags_Flags_ARRAYSIZE = CMsgSteamDatagramConnectionStatsRouterToServer_Flags_Flags_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* CMsgSteamDatagramConnectionStatsRouterToServer_Flags_descriptor();
template<typename T>
inline const std::string& CMsgSteamDatagramConnectionStatsRouterToServer_Flags_Name(T enum_t_value) {
  static_assert(::std::is_same<T, CMsgSteamDatagramConnectionStatsRouterToServer_Flags>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function CMsgSteamDatagramConnectionStatsRouterToServer_Flags_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    CMsgSteamDatagramConnectionStatsRouterToServer_Flags_descriptor(), enum_t_value);
}
inline bool CMsgSteamDatagramConnectionStatsRouterToServer_Flags_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, CMsgSteamDatagramConnectionStatsRouterToServer_Flags* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<CMsgSteamDatagramConnectionStatsRouterToServer_Flags>(
    CMsgSteamDatagramConnectionStatsRouterToServer_Flags_descriptor(), name, value);
}
enum CMsgSteamDatagramConnectionStatsServerToRouter_Flags : int {
  CMsgSteamDatagramConnectionStatsServerToRouter_Flags_ACK_REQUEST_RELAY = 1,
  CMsgSteamDatagramConnectionStatsServerToRouter_Flags_ACK_REQUEST_E2E = 2,
  CMsgSteamDatagramConnectionStatsServerToRouter_Flags_ACK_REQUEST_IMMEDIATE = 4
};
bool CMsgSteamDatagramConnectionStatsServerToRouter_Flags_IsValid(int value);
constexpr CMsgSteamDatagramConnectionStatsServerToRouter_Flags CMsgSteamDatagramConnectionStatsServerToRouter_Flags_Flags_MIN = CMsgSteamDatagramConnectionStatsServerToRouter_Flags_ACK_REQUEST_RELAY;
constexpr CMsgSteamDatagramConnectionStatsServerToRouter_Flags CMsgSteamDatagramConnectionStatsServerToRouter_Flags_Flags_MAX = CMsgSteamDatagramConnectionStatsServerToRouter_Flags_ACK_REQUEST_IMMEDIATE;
constexpr int CMsgSteamDatagramConnectionStatsServerToRouter_Flags_Flags_ARRAYSIZE = CMsgSteamDatagramConnectionStatsServerToRouter_Flags_Flags_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* CMsgSteamDatagramConnectionStatsServerToRouter_Flags_descriptor();
template<typename T>
inline const std::string& CMsgSteamDatagramConnectionStatsServerToRouter_Flags_Name(T enum_t_value) {
  static_assert(::std::is_same<T, CMsgSteamDatagramConnectionStatsServerToRouter_Flags>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function CMsgSteamDatagramConnectionStatsServerToRouter_Flags_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    CMsgSteamDatagramConnectionStatsServerToRouter_Flags_descriptor(), enum_t_value);
}
inline bool CMsgSteamDatagramConnectionStatsServerToRouter_Flags_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, CMsgSteamDatagramConnectionStatsServerToRouter_Flags* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<CMsgSteamDatagramConnectionStatsServerToRouter_Flags>(
    CMsgSteamDatagramConnectionStatsServerToRouter_Flags_descriptor(), name, value);
}
enum CMsgSteamDatagramConnectionStatsP2PClientToRouter_Flags : int {
  CMsgSteamDatagramConnectionStatsP2PClientToRouter_Flags_ACK_REQUEST_RELAY = 1,
  CMsgSteamDatagramConnectionStatsP2PClientToRouter_Flags_ACK_REQUEST_E2E = 2,
  CMsgSteamDatagramConnectionStatsP2PClientToRouter_Flags_ACK_REQUEST_IMMEDIATE = 4,
  CMsgSteamDatagramConnectionStatsP2PClientToRouter_Flags_NOT_PRIMARY_SESSION = 8,
  CMsgSteamDatagramConnectionStatsP2PClientToRouter_Flags_NOT_PRIMARY_TRANSPORT_E2E = 16,
  CMsgSteamDatagramConnectionStatsP2PClientToRouter_Flags_CLIENT_RELAY_OVERRIDE = 32
};
bool CMsgSteamDatagramConnectionStatsP2PClientToRouter_Flags_IsValid(int value);
constexpr CMsgSteamDatagramConnectionStatsP2PClientToRouter_Flags CMsgSteamDatagramConnectionStatsP2PClientToRouter_Flags_Flags_MIN = CMsgSteamDatagramConnectionStatsP2PClientToRouter_Flags_ACK_REQUEST_RELAY;
constexpr CMsgSteamDatagramConnectionStatsP2PClientToRouter_Flags CMsgSteamDatagramConnectionStatsP2PClientToRouter_Flags_Flags_MAX = CMsgSteamDatagramConnectionStatsP2PClientToRouter_Flags_CLIENT_RELAY_OVERRIDE;
constexpr int CMsgSteamDatagramConnectionStatsP2PClientToRouter_Flags_Flags_ARRAYSIZE = CMsgSteamDatagramConnectionStatsP2PClientToRouter_Flags_Flags_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* CMsgSteamDatagramConnectionStatsP2PClientToRouter_Flags_descriptor();
template<typename T>
inline const std::string& CMsgSteamDatagramConnectionStatsP2PClientToRouter_Flags_Name(T enum_t_value) {
  static_assert(::std::is_same<T, CMsgSteamDatagramConnectionStatsP2PClientToRouter_Flags>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function CMsgSteamDatagramConnectionStatsP2PClientToRouter_Flags_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    CMsgSteamDatagramConnectionStatsP2PClientToRouter_Flags_descriptor(), enum_t_value);
}
inline bool CMsgSteamDatagramConnectionStatsP2PClientToRouter_Flags_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, CMsgSteamDatagramConnectionStatsP2PClientToRouter_Flags* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<CMsgSteamDatagramConnectionStatsP2PClientToRouter_Flags>(
    CMsgSteamDatagramConnectionStatsP2PClientToRouter_Flags_descriptor(), name, value);
}
enum CMsgSteamDatagramConnectionStatsP2PRouterToClient_Flags : int {
  CMsgSteamDatagramConnectionStatsP2PRouterToClient_Flags_ACK_REQUEST_RELAY = 1,
  CMsgSteamDatagramConnectionStatsP2PRouterToClient_Flags_ACK_REQUEST_E2E = 2,
  CMsgSteamDatagramConnectionStatsP2PRouterToClient_Flags_ACK_REQUEST_IMMEDIATE = 4,
  CMsgSteamDatagramConnectionStatsP2PRouterToClient_Flags_NOT_PRIMARY_TRANSPORT_E2E = 16
};
bool CMsgSteamDatagramConnectionStatsP2PRouterToClient_Flags_IsValid(int value);
constexpr CMsgSteamDatagramConnectionStatsP2PRouterToClient_Flags CMsgSteamDatagramConnectionStatsP2PRouterToClient_Flags_Flags_MIN = CMsgSteamDatagramConnectionStatsP2PRouterToClient_Flags_ACK_REQUEST_RELAY;
constexpr CMsgSteamDatagramConnectionStatsP2PRouterToClient_Flags CMsgSteamDatagramConnectionStatsP2PRouterToClient_Flags_Flags_MAX = CMsgSteamDatagramConnectionStatsP2PRouterToClient_Flags_NOT_PRIMARY_TRANSPORT_E2E;
constexpr int CMsgSteamDatagramConnectionStatsP2PRouterToClient_Flags_Flags_ARRAYSIZE = CMsgSteamDatagramConnectionStatsP2PRouterToClient_Flags_Flags_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* CMsgSteamDatagramConnectionStatsP2PRouterToClient_Flags_descriptor();
template<typename T>
inline const std::string& CMsgSteamDatagramConnectionStatsP2PRouterToClient_Flags_Name(T enum_t_value) {
  static_assert(::std::is_same<T, CMsgSteamDatagramConnectionStatsP2PRouterToClient_Flags>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function CMsgSteamDatagramConnectionStatsP2PRouterToClient_Flags_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    CMsgSteamDatagramConnectionStatsP2PRouterToClient_Flags_descriptor(), enum_t_value);
}
inline bool CMsgSteamDatagramConnectionStatsP2PRouterToClient_Flags_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, CMsgSteamDatagramConnectionStatsP2PRouterToClient_Flags* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<CMsgSteamDatagramConnectionStatsP2PRouterToClient_Flags>(
    CMsgSteamDatagramConnectionStatsP2PRouterToClient_Flags_descriptor(), name, value);
}
enum ESteamDatagramMsgID : int {
  k_ESteamDatagramMsg_Invalid = 0,
  k_ESteamDatagramMsg_RouterPingRequest = 1,
  k_ESteamDatagramMsg_RouterPingReply = 2,
  k_ESteamDatagramMsg_GameserverPingRequest = 3,
  k_ESteamDatagramMsg_GameserverSessionRequest = 5,
  k_ESteamDatagramMsg_GameserverSessionEstablished = 6,
  k_ESteamDatagramMsg_NoSession = 7,
  k_ESteamDatagramMsg_Diagnostic = 8,
  k_ESteamDatagramMsg_DataClientToRouter = 9,
  k_ESteamDatagramMsg_DataRouterToServer = 10,
  k_ESteamDatagramMsg_DataServerToRouter = 11,
  k_ESteamDatagramMsg_DataRouterToClient = 12,
  k_ESteamDatagramMsg_Stats = 13,
  k_ESteamDatagramMsg_ClientPingSampleRequest = 14,
  k_ESteamDatagramMsg_ClientPingSampleReply = 15,
  k_ESteamDatagramMsg_ClientToRouterSwitchedPrimary = 16,
  k_ESteamDatagramMsg_RelayHealth = 17,
  k_ESteamDatagramMsg_ConnectRequest = 18,
  k_ESteamDatagramMsg_ConnectOK = 19,
  k_ESteamDatagramMsg_ConnectionClosed = 20,
  k_ESteamDatagramMsg_NoConnection = 21,
  k_ESteamDatagramMsg_TicketDecryptRequest = 22,
  k_ESteamDatagramMsg_TicketDecryptReply = 23,
  k_ESteamDatagramMsg_P2PSessionRequest = 24,
  k_ESteamDatagramMsg_P2PSessionEstablished = 25,
  k_ESteamDatagramMsg_P2PStatsClient = 26,
  k_ESteamDatagramMsg_P2PStatsRelay = 27,
  k_ESteamDatagramMsg_P2PBadRoute = 28,
  k_ESteamDatagramMsg_GameserverPingReply = 29,
  k_ESteamDatagramMsg_LegacyGameserverRegistration = 30,
  k_ESteamDatagramMsg_SetSecondaryAddressRequest = 31,
  k_ESteamDatagramMsg_SetSecondaryAddressResult = 32,
  k_ESteamDatagramMsg_RelayToRelayPingRequest = 33,
  k_ESteamDatagramMsg_RelayToRelayPingReply = 34
};
bool ESteamDatagramMsgID_IsValid(int value);
constexpr ESteamDatagramMsgID ESteamDatagramMsgID_MIN = k_ESteamDatagramMsg_Invalid;
constexpr ESteamDatagramMsgID ESteamDatagramMsgID_MAX = k_ESteamDatagramMsg_RelayToRelayPingReply;
constexpr int ESteamDatagramMsgID_ARRAYSIZE = ESteamDatagramMsgID_MAX + 1;

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

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

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

  inline CMsgSteamNetworkingIPAddress& operator=(const CMsgSteamNetworkingIPAddress& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgSteamNetworkingIPAddress& operator=(CMsgSteamNetworkingIPAddress&& 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 CMsgSteamNetworkingIPAddress& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgSteamNetworkingIPAddress* internal_default_instance() {
    return reinterpret_cast<const CMsgSteamNetworkingIPAddress*>(
               &_CMsgSteamNetworkingIPAddress_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  friend void swap(CMsgSteamNetworkingIPAddress& a, CMsgSteamNetworkingIPAddress& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgSteamNetworkingIPAddress* 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(CMsgSteamNetworkingIPAddress* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CMsgSteamNetworkingIPAddress* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgSteamNetworkingIPAddress>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgSteamNetworkingIPAddress& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgSteamNetworkingIPAddress& from) {
    CMsgSteamNetworkingIPAddress::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(CMsgSteamNetworkingIPAddress* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgSteamNetworkingIPAddress";
  }
  protected:
  explicit CMsgSteamNetworkingIPAddress(::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 {
    kV6FieldNumber = 2,
    kV4FieldNumber = 1,
  };
  // optional bytes v6 = 2;
  bool has_v6() const;
  private:
  bool _internal_has_v6() const;
  public:
  void clear_v6();
  const std::string& v6() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_v6(ArgT0&& arg0, ArgT... args);
  std::string* mutable_v6();
  PROTOBUF_NODISCARD std::string* release_v6();
  void set_allocated_v6(std::string* v6);
  private:
  const std::string& _internal_v6() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_v6(const std::string& value);
  std::string* _internal_mutable_v6();
  public:

  // optional fixed32 v4 = 1;
  bool has_v4() const;
  private:
  bool _internal_has_v4() const;
  public:
  void clear_v4();
  uint32_t v4() const;
  void set_v4(uint32_t value);
  private:
  uint32_t _internal_v4() const;
  void _internal_set_v4(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgSteamNetworkingIPAddress)
 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 v6_;
    uint32_t v4_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_steamdatagram_5fmessages_5fsdr_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CMsgSteamDatagramSignedMessageGeneric& operator=(const CMsgSteamDatagramSignedMessageGeneric& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgSteamDatagramSignedMessageGeneric& operator=(CMsgSteamDatagramSignedMessageGeneric&& 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 CMsgSteamDatagramSignedMessageGeneric& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgSteamDatagramSignedMessageGeneric* internal_default_instance() {
    return reinterpret_cast<const CMsgSteamDatagramSignedMessageGeneric*>(
               &_CMsgSteamDatagramSignedMessageGeneric_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

  friend void swap(CMsgSteamDatagramSignedMessageGeneric& a, CMsgSteamDatagramSignedMessageGeneric& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgSteamDatagramSignedMessageGeneric* 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(CMsgSteamDatagramSignedMessageGeneric* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CMsgSteamDatagramSignedMessageGeneric* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgSteamDatagramSignedMessageGeneric>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgSteamDatagramSignedMessageGeneric& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgSteamDatagramSignedMessageGeneric& from) {
    CMsgSteamDatagramSignedMessageGeneric::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(CMsgSteamDatagramSignedMessageGeneric* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgSteamDatagramSignedMessageGeneric";
  }
  protected:
  explicit CMsgSteamDatagramSignedMessageGeneric(::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 {
    kSignedDataFieldNumber = 2,
    kSignatureFieldNumber = 3,
    kDummyPadFieldNumber = 1023,
    kCertFieldNumber = 1,
  };
  // optional bytes signed_data = 2;
  bool has_signed_data() const;
  private:
  bool _internal_has_signed_data() const;
  public:
  void clear_signed_data();
  const std::string& signed_data() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_signed_data(ArgT0&& arg0, ArgT... args);
  std::string* mutable_signed_data();
  PROTOBUF_NODISCARD std::string* release_signed_data();
  void set_allocated_signed_data(std::string* signed_data);
  private:
  const std::string& _internal_signed_data() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_signed_data(const std::string& value);
  std::string* _internal_mutable_signed_data();
  public:

  // optional bytes signature = 3;
  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:

  // optional bytes dummy_pad = 1023;
  bool has_dummy_pad() const;
  private:
  bool _internal_has_dummy_pad() const;
  public:
  void clear_dummy_pad();
  const std::string& dummy_pad() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_dummy_pad(ArgT0&& arg0, ArgT... args);
  std::string* mutable_dummy_pad();
  PROTOBUF_NODISCARD std::string* release_dummy_pad();
  void set_allocated_dummy_pad(std::string* dummy_pad);
  private:
  const std::string& _internal_dummy_pad() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_dummy_pad(const std::string& value);
  std::string* _internal_mutable_dummy_pad();
  public:

  // optional .CMsgSteamDatagramCertificateSigned cert = 1;
  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:CMsgSteamDatagramSignedMessageGeneric)
 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 signed_data_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr signature_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr dummy_pad_;
    ::CMsgSteamDatagramCertificateSigned* cert_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_steamdatagram_5fmessages_5fsdr_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CMsgSteamDatagramRouterPingReply_RouteException& operator=(const CMsgSteamDatagramRouterPingReply_RouteException& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgSteamDatagramRouterPingReply_RouteException& operator=(CMsgSteamDatagramRouterPingReply_RouteException&& 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 CMsgSteamDatagramRouterPingReply_RouteException& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgSteamDatagramRouterPingReply_RouteException* internal_default_instance() {
    return reinterpret_cast<const CMsgSteamDatagramRouterPingReply_RouteException*>(
               &_CMsgSteamDatagramRouterPingReply_RouteException_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

  friend void swap(CMsgSteamDatagramRouterPingReply_RouteException& a, CMsgSteamDatagramRouterPingReply_RouteException& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgSteamDatagramRouterPingReply_RouteException* 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(CMsgSteamDatagramRouterPingReply_RouteException* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CMsgSteamDatagramRouterPingReply_RouteException* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgSteamDatagramRouterPingReply_RouteException>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgSteamDatagramRouterPingReply_RouteException& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgSteamDatagramRouterPingReply_RouteException& from) {
    CMsgSteamDatagramRouterPingReply_RouteException::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(CMsgSteamDatagramRouterPingReply_RouteException* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgSteamDatagramRouterPingReply.RouteException";
  }
  protected:
  explicit CMsgSteamDatagramRouterPingReply_RouteException(::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 {
    kDataCenterIdFieldNumber = 1,
    kFlagsFieldNumber = 2,
    kPenaltyFieldNumber = 3,
  };
  // optional fixed32 data_center_id = 1;
  bool has_data_center_id() const;
  private:
  bool _internal_has_data_center_id() const;
  public:
  void clear_data_center_id();
  uint32_t data_center_id() const;
  void set_data_center_id(uint32_t value);
  private:
  uint32_t _internal_data_center_id() const;
  void _internal_set_data_center_id(uint32_t value);
  public:

  // optional uint32 flags = 2;
  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 penalty = 3;
  bool has_penalty() const;
  private:
  bool _internal_has_penalty() const;
  public:
  void clear_penalty();
  uint32_t penalty() const;
  void set_penalty(uint32_t value);
  private:
  uint32_t _internal_penalty() const;
  void _internal_set_penalty(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgSteamDatagramRouterPingReply.RouteException)
 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 data_center_id_;
    uint32_t flags_;
    uint32_t penalty_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_steamdatagram_5fmessages_5fsdr_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CMsgSteamDatagramRouterPingReply_AltAddress& operator=(const CMsgSteamDatagramRouterPingReply_AltAddress& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgSteamDatagramRouterPingReply_AltAddress& operator=(CMsgSteamDatagramRouterPingReply_AltAddress&& 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 CMsgSteamDatagramRouterPingReply_AltAddress& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgSteamDatagramRouterPingReply_AltAddress* internal_default_instance() {
    return reinterpret_cast<const CMsgSteamDatagramRouterPingReply_AltAddress*>(
               &_CMsgSteamDatagramRouterPingReply_AltAddress_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

  friend void swap(CMsgSteamDatagramRouterPingReply_AltAddress& a, CMsgSteamDatagramRouterPingReply_AltAddress& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgSteamDatagramRouterPingReply_AltAddress* 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(CMsgSteamDatagramRouterPingReply_AltAddress* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CMsgSteamDatagramRouterPingReply_AltAddress* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgSteamDatagramRouterPingReply_AltAddress>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgSteamDatagramRouterPingReply_AltAddress& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgSteamDatagramRouterPingReply_AltAddress& from) {
    CMsgSteamDatagramRouterPingReply_AltAddress::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(CMsgSteamDatagramRouterPingReply_AltAddress* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgSteamDatagramRouterPingReply.AltAddress";
  }
  protected:
  explicit CMsgSteamDatagramRouterPingReply_AltAddress(::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 CMsgSteamDatagramRouterPingReply_AltAddress_Protocol Protocol;
  static constexpr Protocol DefaultProtocol =
    CMsgSteamDatagramRouterPingReply_AltAddress_Protocol_DefaultProtocol;
  static inline bool Protocol_IsValid(int value) {
    return CMsgSteamDatagramRouterPingReply_AltAddress_Protocol_IsValid(value);
  }
  static constexpr Protocol Protocol_MIN =
    CMsgSteamDatagramRouterPingReply_AltAddress_Protocol_Protocol_MIN;
  static constexpr Protocol Protocol_MAX =
    CMsgSteamDatagramRouterPingReply_AltAddress_Protocol_Protocol_MAX;
  static constexpr int Protocol_ARRAYSIZE =
    CMsgSteamDatagramRouterPingReply_AltAddress_Protocol_Protocol_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  Protocol_descriptor() {
    return CMsgSteamDatagramRouterPingReply_AltAddress_Protocol_descriptor();
  }
  template<typename T>
  static inline const std::string& Protocol_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Protocol>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Protocol_Name.");
    return CMsgSteamDatagramRouterPingReply_AltAddress_Protocol_Name(enum_t_value);
  }
  static inline bool Protocol_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Protocol* value) {
    return CMsgSteamDatagramRouterPingReply_AltAddress_Protocol_Parse(name, value);
  }

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

  enum : int {
    kIdFieldNumber = 5,
    kIpv4FieldNumber = 1,
    kPortFieldNumber = 2,
    kPenaltyFieldNumber = 3,
    kProtocolFieldNumber = 4,
  };
  // optional string id = 5;
  bool has_id() const;
  private:
  bool _internal_has_id() const;
  public:
  void clear_id();
  const std::string& id() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_id(ArgT0&& arg0, ArgT... args);
  std::string* mutable_id();
  PROTOBUF_NODISCARD std::string* release_id();
  void set_allocated_id(std::string* id);
  private:
  const std::string& _internal_id() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_id(const std::string& value);
  std::string* _internal_mutable_id();
  public:

  // optional fixed32 ipv4 = 1;
  bool has_ipv4() const;
  private:
  bool _internal_has_ipv4() const;
  public:
  void clear_ipv4();
  uint32_t ipv4() const;
  void set_ipv4(uint32_t value);
  private:
  uint32_t _internal_ipv4() const;
  void _internal_set_ipv4(uint32_t value);
  public:

  // optional uint32 port = 2;
  bool has_port() const;
  private:
  bool _internal_has_port() const;
  public:
  void clear_port();
  uint32_t port() const;
  void set_port(uint32_t value);
  private:
  uint32_t _internal_port() const;
  void _internal_set_port(uint32_t value);
  public:

  // optional uint32 penalty = 3;
  bool has_penalty() const;
  private:
  bool _internal_has_penalty() const;
  public:
  void clear_penalty();
  uint32_t penalty() const;
  void set_penalty(uint32_t value);
  private:
  uint32_t _internal_penalty() const;
  void _internal_set_penalty(uint32_t value);
  public:

  // optional .CMsgSteamDatagramRouterPingReply.AltAddress.Protocol protocol = 4 [default = DefaultProtocol];
  bool has_protocol() const;
  private:
  bool _internal_has_protocol() const;
  public:
  void clear_protocol();
  ::CMsgSteamDatagramRouterPingReply_AltAddress_Protocol protocol() const;
  void set_protocol(::CMsgSteamDatagramRouterPingReply_AltAddress_Protocol value);
  private:
  ::CMsgSteamDatagramRouterPingReply_AltAddress_Protocol _internal_protocol() const;
  void _internal_set_protocol(::CMsgSteamDatagramRouterPingReply_AltAddress_Protocol value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgSteamDatagramRouterPingReply.AltAddress)
 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 id_;
    uint32_t ipv4_;
    uint32_t port_;
    uint32_t penalty_;
    int protocol_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_steamdatagram_5fmessages_5fsdr_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CMsgSteamDatagramRouterPingReply& operator=(const CMsgSteamDatagramRouterPingReply& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgSteamDatagramRouterPingReply& operator=(CMsgSteamDatagramRouterPingReply&& 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 CMsgSteamDatagramRouterPingReply& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgSteamDatagramRouterPingReply* internal_default_instance() {
    return reinterpret_cast<const CMsgSteamDatagramRouterPingReply*>(
               &_CMsgSteamDatagramRouterPingReply_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

  friend void swap(CMsgSteamDatagramRouterPingReply& a, CMsgSteamDatagramRouterPingReply& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgSteamDatagramRouterPingReply* 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(CMsgSteamDatagramRouterPingReply* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CMsgSteamDatagramRouterPingReply* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgSteamDatagramRouterPingReply>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgSteamDatagramRouterPingReply& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgSteamDatagramRouterPingReply& from) {
    CMsgSteamDatagramRouterPingReply::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(CMsgSteamDatagramRouterPingReply* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgSteamDatagramRouterPingReply";
  }
  protected:
  explicit CMsgSteamDatagramRouterPingReply(::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 CMsgSteamDatagramRouterPingReply_RouteException RouteException;
  typedef CMsgSteamDatagramRouterPingReply_AltAddress AltAddress;

  typedef CMsgSteamDatagramRouterPingReply_Flags Flags;
  static constexpr Flags FLAG_MAYBE_MORE_DATA_CENTERS =
    CMsgSteamDatagramRouterPingReply_Flags_FLAG_MAYBE_MORE_DATA_CENTERS;
  static constexpr Flags FLAG_MAYBE_MORE_ALT_ADDRESSES =
    CMsgSteamDatagramRouterPingReply_Flags_FLAG_MAYBE_MORE_ALT_ADDRESSES;
  static inline bool Flags_IsValid(int value) {
    return CMsgSteamDatagramRouterPingReply_Flags_IsValid(value);
  }
  static constexpr Flags Flags_MIN =
    CMsgSteamDatagramRouterPingReply_Flags_Flags_MIN;
  static constexpr Flags Flags_MAX =
    CMsgSteamDatagramRouterPingReply_Flags_Flags_MAX;
  static constexpr int Flags_ARRAYSIZE =
    CMsgSteamDatagramRouterPingReply_Flags_Flags_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  Flags_descriptor() {
    return CMsgSteamDatagramRouterPingReply_Flags_descriptor();
  }
  template<typename T>
  static inline const std::string& Flags_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Flags>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Flags_Name.");
    return CMsgSteamDatagramRouterPingReply_Flags_Name(enum_t_value);
  }
  static inline bool Flags_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Flags* value) {
    return CMsgSteamDatagramRouterPingReply_Flags_Parse(name, value);
  }

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

  enum : int {
    kLatencyDatacenterIdsFieldNumber = 2,
    kLatencyPingMsFieldNumber = 3,
    kRouteExceptionsFieldNumber = 10,
    kAltAddressesFieldNumber = 13,
    kLatencyDatacenterIdsP2PFieldNumber = 14,
    kLatencyPingMsP2PFieldNumber = 15,
    kDummyPadFieldNumber = 99,
    kClientTimestampFieldNumber = 1,
    kYourPublicIpFieldNumber = 4,
    kChallengeFieldNumber = 6,
    kServerTimeFieldNumber = 5,
    kSecondsUntilShutdownFieldNumber = 7,
    kClientCookieFieldNumber = 8,
    kScoringPenaltyRelayClusterFieldNumber = 9,
    kYourPublicPortFieldNumber = 11,
    kFlagsFieldNumber = 12,
    kRecvTosFieldNumber = 16,
    kEchoSentTosFieldNumber = 17,
    kSentTosFieldNumber = 18,
    kEchoRequestReplyTosFieldNumber = 19,
    kDummyVarintFieldNumber = 100,
  };
  // repeated fixed32 latency_datacenter_ids = 2 [packed = true];
  int latency_datacenter_ids_size() const;
  private:
  int _internal_latency_datacenter_ids_size() const;
  public:
  void clear_latency_datacenter_ids();
  private:
  uint32_t _internal_latency_datacenter_ids(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      _internal_latency_datacenter_ids() const;
  void _internal_add_latency_datacenter_ids(uint32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      _internal_mutable_latency_datacenter_ids();
  public:
  uint32_t latency_datacenter_ids(int index) const;
  void set_latency_datacenter_ids(int index, uint32_t value);
  void add_latency_datacenter_ids(uint32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      latency_datacenter_ids() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      mutable_latency_datacenter_ids();

  // repeated uint32 latency_ping_ms = 3 [packed = true];
  int latency_ping_ms_size() const;
  private:
  int _internal_latency_ping_ms_size() const;
  public:
  void clear_latency_ping_ms();
  private:
  uint32_t _internal_latency_ping_ms(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      _internal_latency_ping_ms() const;
  void _internal_add_latency_ping_ms(uint32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      _internal_mutable_latency_ping_ms();
  public:
  uint32_t latency_ping_ms(int index) const;
  void set_latency_ping_ms(int index, uint32_t value);
  void add_latency_ping_ms(uint32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      latency_ping_ms() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      mutable_latency_ping_ms();

  // repeated .CMsgSteamDatagramRouterPingReply.RouteException route_exceptions = 10;
  int route_exceptions_size() const;
  private:
  int _internal_route_exceptions_size() const;
  public:
  void clear_route_exceptions();
  ::CMsgSteamDatagramRouterPingReply_RouteException* mutable_route_exceptions(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgSteamDatagramRouterPingReply_RouteException >*
      mutable_route_exceptions();
  private:
  const ::CMsgSteamDatagramRouterPingReply_RouteException& _internal_route_exceptions(int index) const;
  ::CMsgSteamDatagramRouterPingReply_RouteException* _internal_add_route_exceptions();
  public:
  const ::CMsgSteamDatagramRouterPingReply_RouteException& route_exceptions(int index) const;
  ::CMsgSteamDatagramRouterPingReply_RouteException* add_route_exceptions();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgSteamDatagramRouterPingReply_RouteException >&
      route_exceptions() const;

  // repeated .CMsgSteamDatagramRouterPingReply.AltAddress alt_addresses = 13;
  int alt_addresses_size() const;
  private:
  int _internal_alt_addresses_size() const;
  public:
  void clear_alt_addresses();
  ::CMsgSteamDatagramRouterPingReply_AltAddress* mutable_alt_addresses(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgSteamDatagramRouterPingReply_AltAddress >*
      mutable_alt_addresses();
  private:
  const ::CMsgSteamDatagramRouterPingReply_AltAddress& _internal_alt_addresses(int index) const;
  ::CMsgSteamDatagramRouterPingReply_AltAddress* _internal_add_alt_addresses();
  public:
  const ::CMsgSteamDatagramRouterPingReply_AltAddress& alt_addresses(int index) const;
  ::CMsgSteamDatagramRouterPingReply_AltAddress* add_alt_addresses();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgSteamDatagramRouterPingReply_AltAddress >&
      alt_addresses() const;

  // repeated fixed32 latency_datacenter_ids_p2p = 14 [packed = true];
  int latency_datacenter_ids_p2p_size() const;
  private:
  int _internal_latency_datacenter_ids_p2p_size() const;
  public:
  void clear_latency_datacenter_ids_p2p();
  private:
  uint32_t _internal_latency_datacenter_ids_p2p(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      _internal_latency_datacenter_ids_p2p() const;
  void _internal_add_latency_datacenter_ids_p2p(uint32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      _internal_mutable_latency_datacenter_ids_p2p();
  public:
  uint32_t latency_datacenter_ids_p2p(int index) const;
  void set_latency_datacenter_ids_p2p(int index, uint32_t value);
  void add_latency_datacenter_ids_p2p(uint32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      latency_datacenter_ids_p2p() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      mutable_latency_datacenter_ids_p2p();

  // repeated uint32 latency_ping_ms_p2p = 15 [packed = true];
  int latency_ping_ms_p2p_size() const;
  private:
  int _internal_latency_ping_ms_p2p_size() const;
  public:
  void clear_latency_ping_ms_p2p();
  private:
  uint32_t _internal_latency_ping_ms_p2p(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      _internal_latency_ping_ms_p2p() const;
  void _internal_add_latency_ping_ms_p2p(uint32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      _internal_mutable_latency_ping_ms_p2p();
  public:
  uint32_t latency_ping_ms_p2p(int index) const;
  void set_latency_ping_ms_p2p(int index, uint32_t value);
  void add_latency_ping_ms_p2p(uint32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      latency_ping_ms_p2p() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      mutable_latency_ping_ms_p2p();

  // optional bytes dummy_pad = 99;
  bool has_dummy_pad() const;
  private:
  bool _internal_has_dummy_pad() const;
  public:
  void clear_dummy_pad();
  const std::string& dummy_pad() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_dummy_pad(ArgT0&& arg0, ArgT... args);
  std::string* mutable_dummy_pad();
  PROTOBUF_NODISCARD std::string* release_dummy_pad();
  void set_allocated_dummy_pad(std::string* dummy_pad);
  private:
  const std::string& _internal_dummy_pad() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_dummy_pad(const std::string& value);
  std::string* _internal_mutable_dummy_pad();
  public:

  // optional fixed32 client_timestamp = 1;
  bool has_client_timestamp() const;
  private:
  bool _internal_has_client_timestamp() const;
  public:
  void clear_client_timestamp();
  uint32_t client_timestamp() const;
  void set_client_timestamp(uint32_t value);
  private:
  uint32_t _internal_client_timestamp() const;
  void _internal_set_client_timestamp(uint32_t value);
  public:

  // optional fixed32 your_public_ip = 4;
  bool has_your_public_ip() const;
  private:
  bool _internal_has_your_public_ip() const;
  public:
  void clear_your_public_ip();
  uint32_t your_public_ip() const;
  void set_your_public_ip(uint32_t value);
  private:
  uint32_t _internal_your_public_ip() const;
  void _internal_set_your_public_ip(uint32_t value);
  public:

  // optional fixed64 challenge = 6;
  bool has_challenge() const;
  private:
  bool _internal_has_challenge() const;
  public:
  void clear_challenge();
  uint64_t challenge() const;
  void set_challenge(uint64_t value);
  private:
  uint64_t _internal_challenge() const;
  void _internal_set_challenge(uint64_t value);
  public:

  // optional fixed32 server_time = 5;
  bool has_server_time() const;
  private:
  bool _internal_has_server_time() const;
  public:
  void clear_server_time();
  uint32_t server_time() const;
  void set_server_time(uint32_t value);
  private:
  uint32_t _internal_server_time() const;
  void _internal_set_server_time(uint32_t value);
  public:

  // optional uint32 seconds_until_shutdown = 7;
  bool has_seconds_until_shutdown() const;
  private:
  bool _internal_has_seconds_until_shutdown() const;
  public:
  void clear_seconds_until_shutdown();
  uint32_t seconds_until_shutdown() const;
  void set_seconds_until_shutdown(uint32_t value);
  private:
  uint32_t _internal_seconds_until_shutdown() const;
  void _internal_set_seconds_until_shutdown(uint32_t value);
  public:

  // optional fixed32 client_cookie = 8;
  bool has_client_cookie() const;
  private:
  bool _internal_has_client_cookie() const;
  public:
  void clear_client_cookie();
  uint32_t client_cookie() const;
  void set_client_cookie(uint32_t value);
  private:
  uint32_t _internal_client_cookie() const;
  void _internal_set_client_cookie(uint32_t value);
  public:

  // optional uint32 scoring_penalty_relay_cluster = 9;
  bool has_scoring_penalty_relay_cluster() const;
  private:
  bool _internal_has_scoring_penalty_relay_cluster() const;
  public:
  void clear_scoring_penalty_relay_cluster();
  uint32_t scoring_penalty_relay_cluster() const;
  void set_scoring_penalty_relay_cluster(uint32_t value);
  private:
  uint32_t _internal_scoring_penalty_relay_cluster() const;
  void _internal_set_scoring_penalty_relay_cluster(uint32_t value);
  public:

  // optional fixed32 your_public_port = 11;
  bool has_your_public_port() const;
  private:
  bool _internal_has_your_public_port() const;
  public:
  void clear_your_public_port();
  uint32_t your_public_port() const;
  void set_your_public_port(uint32_t value);
  private:
  uint32_t _internal_your_public_port() const;
  void _internal_set_your_public_port(uint32_t value);
  public:

  // optional uint32 flags = 12;
  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 recv_tos = 16;
  bool has_recv_tos() const;
  private:
  bool _internal_has_recv_tos() const;
  public:
  void clear_recv_tos();
  uint32_t recv_tos() const;
  void set_recv_tos(uint32_t value);
  private:
  uint32_t _internal_recv_tos() const;
  void _internal_set_recv_tos(uint32_t value);
  public:

  // optional uint32 echo_sent_tos = 17;
  bool has_echo_sent_tos() const;
  private:
  bool _internal_has_echo_sent_tos() const;
  public:
  void clear_echo_sent_tos();
  uint32_t echo_sent_tos() const;
  void set_echo_sent_tos(uint32_t value);
  private:
  uint32_t _internal_echo_sent_tos() const;
  void _internal_set_echo_sent_tos(uint32_t value);
  public:

  // optional uint32 sent_tos = 18;
  bool has_sent_tos() const;
  private:
  bool _internal_has_sent_tos() const;
  public:
  void clear_sent_tos();
  uint32_t sent_tos() const;
  void set_sent_tos(uint32_t value);
  private:
  uint32_t _internal_sent_tos() const;
  void _internal_set_sent_tos(uint32_t value);
  public:

  // optional uint32 echo_request_reply_tos = 19;
  bool has_echo_request_reply_tos() const;
  private:
  bool _internal_has_echo_request_reply_tos() const;
  public:
  void clear_echo_request_reply_tos();
  uint32_t echo_request_reply_tos() const;
  void set_echo_request_reply_tos(uint32_t value);
  private:
  uint32_t _internal_echo_request_reply_tos() const;
  void _internal_set_echo_request_reply_tos(uint32_t value);
  public:

  // optional uint64 dummy_varint = 100;
  bool has_dummy_varint() const;
  private:
  bool _internal_has_dummy_varint() const;
  public:
  void clear_dummy_varint();
  uint64_t dummy_varint() const;
  void set_dummy_varint(uint64_t value);
  private:
  uint64_t _internal_dummy_varint() const;
  void _internal_set_dummy_varint(uint64_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgSteamDatagramRouterPingReply)
 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< uint32_t > latency_datacenter_ids_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > latency_ping_ms_;
    mutable std::atomic<int> _latency_ping_ms_cached_byte_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgSteamDatagramRouterPingReply_RouteException > route_exceptions_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgSteamDatagramRouterPingReply_AltAddress > alt_addresses_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > latency_datacenter_ids_p2p_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > latency_ping_ms_p2p_;
    mutable std::atomic<int> _latency_ping_ms_p2p_cached_byte_size_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr dummy_pad_;
    uint32_t client_timestamp_;
    uint32_t your_public_ip_;
    uint64_t challenge_;
    uint32_t server_time_;
    uint32_t seconds_until_shutdown_;
    uint32_t client_cookie_;
    uint32_t scoring_penalty_relay_cluster_;
    uint32_t your_public_port_;
    uint32_t flags_;
    uint32_t recv_tos_;
    uint32_t echo_sent_tos_;
    uint32_t sent_tos_;
    uint32_t echo_request_reply_tos_;
    uint64_t dummy_varint_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_steamdatagram_5fmessages_5fsdr_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CMsgSteamDatagramGameserverPingRequestBody& operator=(const CMsgSteamDatagramGameserverPingRequestBody& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgSteamDatagramGameserverPingRequestBody& operator=(CMsgSteamDatagramGameserverPingRequestBody&& 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 CMsgSteamDatagramGameserverPingRequestBody& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgSteamDatagramGameserverPingRequestBody* internal_default_instance() {
    return reinterpret_cast<const CMsgSteamDatagramGameserverPingRequestBody*>(
               &_CMsgSteamDatagramGameserverPingRequestBody_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;

  friend void swap(CMsgSteamDatagramGameserverPingRequestBody& a, CMsgSteamDatagramGameserverPingRequestBody& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgSteamDatagramGameserverPingRequestBody* 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(CMsgSteamDatagramGameserverPingRequestBody* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CMsgSteamDatagramGameserverPingRequestBody* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgSteamDatagramGameserverPingRequestBody>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgSteamDatagramGameserverPingRequestBody& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgSteamDatagramGameserverPingRequestBody& from) {
    CMsgSteamDatagramGameserverPingRequestBody::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(CMsgSteamDatagramGameserverPingRequestBody* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgSteamDatagramGameserverPingRequestBody";
  }
  protected:
  explicit CMsgSteamDatagramGameserverPingRequestBody(::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 {
    kMyIpsFieldNumber = 6,
    kEchoFieldNumber = 8,
    kYourPublicIpFieldNumber = 2,
    kRelayPopidFieldNumber = 1,
    kYourPublicPortFieldNumber = 3,
    kRelayUnixTimeFieldNumber = 4,
    kRoutingSecretFieldNumber = 5,
  };
  // repeated .CMsgSteamNetworkingIPAddress my_ips = 6;
  int my_ips_size() const;
  private:
  int _internal_my_ips_size() const;
  public:
  void clear_my_ips();
  ::CMsgSteamNetworkingIPAddress* mutable_my_ips(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgSteamNetworkingIPAddress >*
      mutable_my_ips();
  private:
  const ::CMsgSteamNetworkingIPAddress& _internal_my_ips(int index) const;
  ::CMsgSteamNetworkingIPAddress* _internal_add_my_ips();
  public:
  const ::CMsgSteamNetworkingIPAddress& my_ips(int index) const;
  ::CMsgSteamNetworkingIPAddress* add_my_ips();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgSteamNetworkingIPAddress >&
      my_ips() const;

  // optional bytes echo = 8;
  bool has_echo() const;
  private:
  bool _internal_has_echo() const;
  public:
  void clear_echo();
  const std::string& echo() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_echo(ArgT0&& arg0, ArgT... args);
  std::string* mutable_echo();
  PROTOBUF_NODISCARD std::string* release_echo();
  void set_allocated_echo(std::string* echo);
  private:
  const std::string& _internal_echo() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_echo(const std::string& value);
  std::string* _internal_mutable_echo();
  public:

  // optional .CMsgSteamNetworkingIPAddress your_public_ip = 2;
  bool has_your_public_ip() const;
  private:
  bool _internal_has_your_public_ip() const;
  public:
  void clear_your_public_ip();
  const ::CMsgSteamNetworkingIPAddress& your_public_ip() const;
  PROTOBUF_NODISCARD ::CMsgSteamNetworkingIPAddress* release_your_public_ip();
  ::CMsgSteamNetworkingIPAddress* mutable_your_public_ip();
  void set_allocated_your_public_ip(::CMsgSteamNetworkingIPAddress* your_public_ip);
  private:
  const ::CMsgSteamNetworkingIPAddress& _internal_your_public_ip() const;
  ::CMsgSteamNetworkingIPAddress* _internal_mutable_your_public_ip();
  public:
  void unsafe_arena_set_allocated_your_public_ip(
      ::CMsgSteamNetworkingIPAddress* your_public_ip);
  ::CMsgSteamNetworkingIPAddress* unsafe_arena_release_your_public_ip();

  // optional fixed32 relay_popid = 1;
  bool has_relay_popid() const;
  private:
  bool _internal_has_relay_popid() const;
  public:
  void clear_relay_popid();
  uint32_t relay_popid() const;
  void set_relay_popid(uint32_t value);
  private:
  uint32_t _internal_relay_popid() const;
  void _internal_set_relay_popid(uint32_t value);
  public:

  // optional uint32 your_public_port = 3;
  bool has_your_public_port() const;
  private:
  bool _internal_has_your_public_port() const;
  public:
  void clear_your_public_port();
  uint32_t your_public_port() const;
  void set_your_public_port(uint32_t value);
  private:
  uint32_t _internal_your_public_port() const;
  void _internal_set_your_public_port(uint32_t value);
  public:

  // optional uint64 relay_unix_time = 4;
  bool has_relay_unix_time() const;
  private:
  bool _internal_has_relay_unix_time() const;
  public:
  void clear_relay_unix_time();
  uint64_t relay_unix_time() const;
  void set_relay_unix_time(uint64_t value);
  private:
  uint64_t _internal_relay_unix_time() const;
  void _internal_set_relay_unix_time(uint64_t value);
  public:

  // optional fixed64 routing_secret = 5;
  bool has_routing_secret() const;
  private:
  bool _internal_has_routing_secret() const;
  public:
  void clear_routing_secret();
  uint64_t routing_secret() const;
  void set_routing_secret(uint64_t value);
  private:
  uint64_t _internal_routing_secret() const;
  void _internal_set_routing_secret(uint64_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgSteamDatagramGameserverPingRequestBody)
 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< ::CMsgSteamNetworkingIPAddress > my_ips_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr echo_;
    ::CMsgSteamNetworkingIPAddress* your_public_ip_;
    uint32_t relay_popid_;
    uint32_t your_public_port_;
    uint64_t relay_unix_time_;
    uint64_t routing_secret_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_steamdatagram_5fmessages_5fsdr_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CMsgSteamDatagramGameserverPingRequestEnvelope& operator=(const CMsgSteamDatagramGameserverPingRequestEnvelope& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgSteamDatagramGameserverPingRequestEnvelope& operator=(CMsgSteamDatagramGameserverPingRequestEnvelope&& 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 CMsgSteamDatagramGameserverPingRequestEnvelope& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgSteamDatagramGameserverPingRequestEnvelope* internal_default_instance() {
    return reinterpret_cast<const CMsgSteamDatagramGameserverPingRequestEnvelope*>(
               &_CMsgSteamDatagramGameserverPingRequestEnvelope_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    6;

  friend void swap(CMsgSteamDatagramGameserverPingRequestEnvelope& a, CMsgSteamDatagramGameserverPingRequestEnvelope& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgSteamDatagramGameserverPingRequestEnvelope* 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(CMsgSteamDatagramGameserverPingRequestEnvelope* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CMsgSteamDatagramGameserverPingRequestEnvelope* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgSteamDatagramGameserverPingRequestEnvelope>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgSteamDatagramGameserverPingRequestEnvelope& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgSteamDatagramGameserverPingRequestEnvelope& from) {
    CMsgSteamDatagramGameserverPingRequestEnvelope::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(CMsgSteamDatagramGameserverPingRequestEnvelope* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgSteamDatagramGameserverPingRequestEnvelope";
  }
  protected:
  explicit CMsgSteamDatagramGameserverPingRequestEnvelope(::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 {
    kSignedDataFieldNumber = 7,
    kSignatureFieldNumber = 8,
    kDummyPadFieldNumber = 1023,
    kCertFieldNumber = 6,
    kLegacyYourPublicIpFieldNumber = 1,
    kLegacyRelayUnixTimeFieldNumber = 2,
    kLegacyChallengeFieldNumber = 3,
    kLegacyRouterTimestampFieldNumber = 4,
    kLegacyYourPublicPortFieldNumber = 5,
  };
  // optional bytes signed_data = 7;
  bool has_signed_data() const;
  private:
  bool _internal_has_signed_data() const;
  public:
  void clear_signed_data();
  const std::string& signed_data() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_signed_data(ArgT0&& arg0, ArgT... args);
  std::string* mutable_signed_data();
  PROTOBUF_NODISCARD std::string* release_signed_data();
  void set_allocated_signed_data(std::string* signed_data);
  private:
  const std::string& _internal_signed_data() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_signed_data(const std::string& value);
  std::string* _internal_mutable_signed_data();
  public:

  // optional bytes signature = 8;
  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:

  // optional bytes dummy_pad = 1023;
  bool has_dummy_pad() const;
  private:
  bool _internal_has_dummy_pad() const;
  public:
  void clear_dummy_pad();
  const std::string& dummy_pad() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_dummy_pad(ArgT0&& arg0, ArgT... args);
  std::string* mutable_dummy_pad();
  PROTOBUF_NODISCARD std::string* release_dummy_pad();
  void set_allocated_dummy_pad(std::string* dummy_pad);
  private:
  const std::string& _internal_dummy_pad() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_dummy_pad(const std::string& value);
  std::string* _internal_mutable_dummy_pad();
  public:

  // 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();

  // optional fixed32 legacy_your_public_ip = 1;
  bool has_legacy_your_public_ip() const;
  private:
  bool _internal_has_legacy_your_public_ip() const;
  public:
  void clear_legacy_your_public_ip();
  uint32_t legacy_your_public_ip() const;
  void set_legacy_your_public_ip(uint32_t value);
  private:
  uint32_t _internal_legacy_your_public_ip() const;
  void _internal_set_legacy_your_public_ip(uint32_t value);
  public:

  // optional fixed32 legacy_relay_unix_time = 2;
  bool has_legacy_relay_unix_time() const;
  private:
  bool _internal_has_legacy_relay_unix_time() const;
  public:
  void clear_legacy_relay_unix_time();
  uint32_t legacy_relay_unix_time() const;
  void set_legacy_relay_unix_time(uint32_t value);
  private:
  uint32_t _internal_legacy_relay_unix_time() const;
  void _internal_set_legacy_relay_unix_time(uint32_t value);
  public:

  // optional fixed64 legacy_challenge = 3;
  bool has_legacy_challenge() const;
  private:
  bool _internal_has_legacy_challenge() const;
  public:
  void clear_legacy_challenge();
  uint64_t legacy_challenge() const;
  void set_legacy_challenge(uint64_t value);
  private:
  uint64_t _internal_legacy_challenge() const;
  void _internal_set_legacy_challenge(uint64_t value);
  public:

  // optional fixed32 legacy_router_timestamp = 4;
  bool has_legacy_router_timestamp() const;
  private:
  bool _internal_has_legacy_router_timestamp() const;
  public:
  void clear_legacy_router_timestamp();
  uint32_t legacy_router_timestamp() const;
  void set_legacy_router_timestamp(uint32_t value);
  private:
  uint32_t _internal_legacy_router_timestamp() const;
  void _internal_set_legacy_router_timestamp(uint32_t value);
  public:

  // optional fixed32 legacy_your_public_port = 5;
  bool has_legacy_your_public_port() const;
  private:
  bool _internal_has_legacy_your_public_port() const;
  public:
  void clear_legacy_your_public_port();
  uint32_t legacy_your_public_port() const;
  void set_legacy_your_public_port(uint32_t value);
  private:
  uint32_t _internal_legacy_your_public_port() const;
  void _internal_set_legacy_your_public_port(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgSteamDatagramGameserverPingRequestEnvelope)
 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 signed_data_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr signature_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr dummy_pad_;
    ::CMsgSteamDatagramCertificateSigned* cert_;
    uint32_t legacy_your_public_ip_;
    uint32_t legacy_relay_unix_time_;
    uint64_t legacy_challenge_;
    uint32_t legacy_router_timestamp_;
    uint32_t legacy_your_public_port_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_steamdatagram_5fmessages_5fsdr_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CMsgSteamDatagramGameserverPingReplyData& operator=(const CMsgSteamDatagramGameserverPingReplyData& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgSteamDatagramGameserverPingReplyData& operator=(CMsgSteamDatagramGameserverPingReplyData&& 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 CMsgSteamDatagramGameserverPingReplyData& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgSteamDatagramGameserverPingReplyData* internal_default_instance() {
    return reinterpret_cast<const CMsgSteamDatagramGameserverPingReplyData*>(
               &_CMsgSteamDatagramGameserverPingReplyData_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    7;

  friend void swap(CMsgSteamDatagramGameserverPingReplyData& a, CMsgSteamDatagramGameserverPingReplyData& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgSteamDatagramGameserverPingReplyData* 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(CMsgSteamDatagramGameserverPingReplyData* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CMsgSteamDatagramGameserverPingReplyData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgSteamDatagramGameserverPingReplyData>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgSteamDatagramGameserverPingReplyData& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgSteamDatagramGameserverPingReplyData& from) {
    CMsgSteamDatagramGameserverPingReplyData::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(CMsgSteamDatagramGameserverPingReplyData* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgSteamDatagramGameserverPingReplyData";
  }
  protected:
  explicit CMsgSteamDatagramGameserverPingReplyData(::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 {
    kEchoFieldNumber = 8,
    kBuildFieldNumber = 9,
    kRoutingBlobFieldNumber = 12,
    kLegacyChallengeFieldNumber = 3,
    kEchoRelayUnixTimeFieldNumber = 2,
    kLegacyRouterTimestampFieldNumber = 4,
    kDataCenterIdFieldNumber = 5,
    kAppidFieldNumber = 6,
    kProtocolVersionFieldNumber = 7,
    kMyUnixTimeFieldNumber = 11,
    kNetworkConfigVersionFieldNumber = 10,
  };
  // optional bytes echo = 8;
  bool has_echo() const;
  private:
  bool _internal_has_echo() const;
  public:
  void clear_echo();
  const std::string& echo() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_echo(ArgT0&& arg0, ArgT... args);
  std::string* mutable_echo();
  PROTOBUF_NODISCARD std::string* release_echo();
  void set_allocated_echo(std::string* echo);
  private:
  const std::string& _internal_echo() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_echo(const std::string& value);
  std::string* _internal_mutable_echo();
  public:

  // optional string build = 9;
  bool has_build() const;
  private:
  bool _internal_has_build() const;
  public:
  void clear_build();
  const std::string& build() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_build(ArgT0&& arg0, ArgT... args);
  std::string* mutable_build();
  PROTOBUF_NODISCARD std::string* release_build();
  void set_allocated_build(std::string* build);
  private:
  const std::string& _internal_build() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_build(const std::string& value);
  std::string* _internal_mutable_build();
  public:

  // optional bytes routing_blob = 12;
  bool has_routing_blob() const;
  private:
  bool _internal_has_routing_blob() const;
  public:
  void clear_routing_blob();
  const std::string& routing_blob() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_routing_blob(ArgT0&& arg0, ArgT... args);
  std::string* mutable_routing_blob();
  PROTOBUF_NODISCARD std::string* release_routing_blob();
  void set_allocated_routing_blob(std::string* routing_blob);
  private:
  const std::string& _internal_routing_blob() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_routing_blob(const std::string& value);
  std::string* _internal_mutable_routing_blob();
  public:

  // optional fixed64 legacy_challenge = 3;
  bool has_legacy_challenge() const;
  private:
  bool _internal_has_legacy_challenge() const;
  public:
  void clear_legacy_challenge();
  uint64_t legacy_challenge() const;
  void set_legacy_challenge(uint64_t value);
  private:
  uint64_t _internal_legacy_challenge() const;
  void _internal_set_legacy_challenge(uint64_t value);
  public:

  // optional fixed32 echo_relay_unix_time = 2;
  bool has_echo_relay_unix_time() const;
  private:
  bool _internal_has_echo_relay_unix_time() const;
  public:
  void clear_echo_relay_unix_time();
  uint32_t echo_relay_unix_time() const;
  void set_echo_relay_unix_time(uint32_t value);
  private:
  uint32_t _internal_echo_relay_unix_time() const;
  void _internal_set_echo_relay_unix_time(uint32_t value);
  public:

  // optional fixed32 legacy_router_timestamp = 4;
  bool has_legacy_router_timestamp() const;
  private:
  bool _internal_has_legacy_router_timestamp() const;
  public:
  void clear_legacy_router_timestamp();
  uint32_t legacy_router_timestamp() const;
  void set_legacy_router_timestamp(uint32_t value);
  private:
  uint32_t _internal_legacy_router_timestamp() const;
  void _internal_set_legacy_router_timestamp(uint32_t value);
  public:

  // optional fixed32 data_center_id = 5;
  bool has_data_center_id() const;
  private:
  bool _internal_has_data_center_id() const;
  public:
  void clear_data_center_id();
  uint32_t data_center_id() const;
  void set_data_center_id(uint32_t value);
  private:
  uint32_t _internal_data_center_id() const;
  void _internal_set_data_center_id(uint32_t value);
  public:

  // optional uint32 appid = 6;
  bool has_appid() const;
  private:
  bool _internal_has_appid() const;
  public:
  void clear_appid();
  uint32_t appid() const;
  void set_appid(uint32_t value);
  private:
  uint32_t _internal_appid() const;
  void _internal_set_appid(uint32_t value);
  public:

  // optional uint32 protocol_version = 7;
  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 fixed32 my_unix_time = 11;
  bool has_my_unix_time() const;
  private:
  bool _internal_has_my_unix_time() const;
  public:
  void clear_my_unix_time();
  uint32_t my_unix_time() const;
  void set_my_unix_time(uint32_t value);
  private:
  uint32_t _internal_my_unix_time() const;
  void _internal_set_my_unix_time(uint32_t value);
  public:

  // optional uint64 network_config_version = 10;
  bool has_network_config_version() const;
  private:
  bool _internal_has_network_config_version() const;
  public:
  void clear_network_config_version();
  uint64_t network_config_version() const;
  void set_network_config_version(uint64_t value);
  private:
  uint64_t _internal_network_config_version() const;
  void _internal_set_network_config_version(uint64_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgSteamDatagramGameserverPingReplyData)
 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 echo_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr build_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr routing_blob_;
    uint64_t legacy_challenge_;
    uint32_t echo_relay_unix_time_;
    uint32_t legacy_router_timestamp_;
    uint32_t data_center_id_;
    uint32_t appid_;
    uint32_t protocol_version_;
    uint32_t my_unix_time_;
    uint64_t network_config_version_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_steamdatagram_5fmessages_5fsdr_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CMsgSteamDatagramNoSessionRelayToClient& operator=(const CMsgSteamDatagramNoSessionRelayToClient& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgSteamDatagramNoSessionRelayToClient& operator=(CMsgSteamDatagramNoSessionRelayToClient&& 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 CMsgSteamDatagramNoSessionRelayToClient& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgSteamDatagramNoSessionRelayToClient* internal_default_instance() {
    return reinterpret_cast<const CMsgSteamDatagramNoSessionRelayToClient*>(
               &_CMsgSteamDatagramNoSessionRelayToClient_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    8;

  friend void swap(CMsgSteamDatagramNoSessionRelayToClient& a, CMsgSteamDatagramNoSessionRelayToClient& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgSteamDatagramNoSessionRelayToClient* 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(CMsgSteamDatagramNoSessionRelayToClient* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CMsgSteamDatagramNoSessionRelayToClient* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgSteamDatagramNoSessionRelayToClient>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgSteamDatagramNoSessionRelayToClient& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgSteamDatagramNoSessionRelayToClient& from) {
    CMsgSteamDatagramNoSessionRelayToClient::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(CMsgSteamDatagramNoSessionRelayToClient* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgSteamDatagramNoSessionRelayToClient";
  }
  protected:
  explicit CMsgSteamDatagramNoSessionRelayToClient(::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 {
    kYourPublicIpFieldNumber = 2,
    kServerTimeFieldNumber = 3,
    kChallengeFieldNumber = 4,
    kSecondsUntilShutdownFieldNumber = 5,
    kYourPublicPortFieldNumber = 6,
    kConnectionIdFieldNumber = 7,
  };
  // optional fixed32 your_public_ip = 2;
  bool has_your_public_ip() const;
  private:
  bool _internal_has_your_public_ip() const;
  public:
  void clear_your_public_ip();
  uint32_t your_public_ip() const;
  void set_your_public_ip(uint32_t value);
  private:
  uint32_t _internal_your_public_ip() const;
  void _internal_set_your_public_ip(uint32_t value);
  public:

  // optional fixed32 server_time = 3;
  bool has_server_time() const;
  private:
  bool _internal_has_server_time() const;
  public:
  void clear_server_time();
  uint32_t server_time() const;
  void set_server_time(uint32_t value);
  private:
  uint32_t _internal_server_time() const;
  void _internal_set_server_time(uint32_t value);
  public:

  // optional fixed64 challenge = 4;
  bool has_challenge() const;
  private:
  bool _internal_has_challenge() const;
  public:
  void clear_challenge();
  uint64_t challenge() const;
  void set_challenge(uint64_t value);
  private:
  uint64_t _internal_challenge() const;
  void _internal_set_challenge(uint64_t value);
  public:

  // optional uint32 seconds_until_shutdown = 5;
  bool has_seconds_until_shutdown() const;
  private:
  bool _internal_has_seconds_until_shutdown() const;
  public:
  void clear_seconds_until_shutdown();
  uint32_t seconds_until_shutdown() const;
  void set_seconds_until_shutdown(uint32_t value);
  private:
  uint32_t _internal_seconds_until_shutdown() const;
  void _internal_set_seconds_until_shutdown(uint32_t value);
  public:

  // optional fixed32 your_public_port = 6;
  bool has_your_public_port() const;
  private:
  bool _internal_has_your_public_port() const;
  public:
  void clear_your_public_port();
  uint32_t your_public_port() const;
  void set_your_public_port(uint32_t value);
  private:
  uint32_t _internal_your_public_port() const;
  void _internal_set_your_public_port(uint32_t value);
  public:

  // optional fixed32 connection_id = 7;
  bool has_connection_id() const;
  private:
  bool _internal_has_connection_id() const;
  public:
  void clear_connection_id();
  uint32_t connection_id() const;
  void set_connection_id(uint32_t value);
  private:
  uint32_t _internal_connection_id() const;
  void _internal_set_connection_id(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgSteamDatagramNoSessionRelayToClient)
 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 your_public_ip_;
    uint32_t server_time_;
    uint64_t challenge_;
    uint32_t seconds_until_shutdown_;
    uint32_t your_public_port_;
    uint32_t connection_id_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_steamdatagram_5fmessages_5fsdr_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CMsgSteamDatagramNoSessionRelayToPeer& operator=(const CMsgSteamDatagramNoSessionRelayToPeer& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgSteamDatagramNoSessionRelayToPeer& operator=(CMsgSteamDatagramNoSessionRelayToPeer&& 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 CMsgSteamDatagramNoSessionRelayToPeer& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgSteamDatagramNoSessionRelayToPeer* internal_default_instance() {
    return reinterpret_cast<const CMsgSteamDatagramNoSessionRelayToPeer*>(
               &_CMsgSteamDatagramNoSessionRelayToPeer_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    9;

  friend void swap(CMsgSteamDatagramNoSessionRelayToPeer& a, CMsgSteamDatagramNoSessionRelayToPeer& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgSteamDatagramNoSessionRelayToPeer* 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(CMsgSteamDatagramNoSessionRelayToPeer* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CMsgSteamDatagramNoSessionRelayToPeer* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgSteamDatagramNoSessionRelayToPeer>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgSteamDatagramNoSessionRelayToPeer& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgSteamDatagramNoSessionRelayToPeer& from) {
    CMsgSteamDatagramNoSessionRelayToPeer::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(CMsgSteamDatagramNoSessionRelayToPeer* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgSteamDatagramNoSessionRelayToPeer";
  }
  protected:
  explicit CMsgSteamDatagramNoSessionRelayToPeer(::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 {
    kLegacyRelaySessionIdFieldNumber = 1,
    kFromRelaySessionIdFieldNumber = 2,
    kKludgePadFieldNumber = 99,
    kFromConnectionIdFieldNumber = 7,
  };
  // optional uint32 legacy_relay_session_id = 1;
  bool has_legacy_relay_session_id() const;
  private:
  bool _internal_has_legacy_relay_session_id() const;
  public:
  void clear_legacy_relay_session_id();
  uint32_t legacy_relay_session_id() const;
  void set_legacy_relay_session_id(uint32_t value);
  private:
  uint32_t _internal_legacy_relay_session_id() const;
  void _internal_set_legacy_relay_session_id(uint32_t value);
  public:

  // optional fixed32 from_relay_session_id = 2;
  bool has_from_relay_session_id() const;
  private:
  bool _internal_has_from_relay_session_id() const;
  public:
  void clear_from_relay_session_id();
  uint32_t from_relay_session_id() const;
  void set_from_relay_session_id(uint32_t value);
  private:
  uint32_t _internal_from_relay_session_id() const;
  void _internal_set_from_relay_session_id(uint32_t value);
  public:

  // optional fixed64 kludge_pad = 99;
  bool has_kludge_pad() const;
  private:
  bool _internal_has_kludge_pad() const;
  public:
  void clear_kludge_pad();
  uint64_t kludge_pad() const;
  void set_kludge_pad(uint64_t value);
  private:
  uint64_t _internal_kludge_pad() const;
  void _internal_set_kludge_pad(uint64_t value);
  public:

  // optional fixed32 from_connection_id = 7;
  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:

  // @@protoc_insertion_point(class_scope:CMsgSteamDatagramNoSessionRelayToPeer)
 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 legacy_relay_session_id_;
    uint32_t from_relay_session_id_;
    uint64_t kludge_pad_;
    uint32_t from_connection_id_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_steamdatagram_5fmessages_5fsdr_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CMsgTOSTreatment& operator=(const CMsgTOSTreatment& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgTOSTreatment& operator=(CMsgTOSTreatment&& 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 CMsgTOSTreatment& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgTOSTreatment* internal_default_instance() {
    return reinterpret_cast<const CMsgTOSTreatment*>(
               &_CMsgTOSTreatment_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    10;

  friend void swap(CMsgTOSTreatment& a, CMsgTOSTreatment& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgTOSTreatment* 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(CMsgTOSTreatment* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CMsgTOSTreatment* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgTOSTreatment>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgTOSTreatment& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgTOSTreatment& from) {
    CMsgTOSTreatment::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(CMsgTOSTreatment* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgTOSTreatment";
  }
  protected:
  explicit CMsgTOSTreatment(::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 {
    kL4SDetectFieldNumber = 1,
    kUpEcn1FieldNumber = 2,
    kDownDscp45FieldNumber = 3,
  };
  // optional string l4s_detect = 1;
  bool has_l4s_detect() const;
  private:
  bool _internal_has_l4s_detect() const;
  public:
  void clear_l4s_detect();
  const std::string& l4s_detect() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_l4s_detect(ArgT0&& arg0, ArgT... args);
  std::string* mutable_l4s_detect();
  PROTOBUF_NODISCARD std::string* release_l4s_detect();
  void set_allocated_l4s_detect(std::string* l4s_detect);
  private:
  const std::string& _internal_l4s_detect() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_l4s_detect(const std::string& value);
  std::string* _internal_mutable_l4s_detect();
  public:

  // optional string up_ecn1 = 2;
  bool has_up_ecn1() const;
  private:
  bool _internal_has_up_ecn1() const;
  public:
  void clear_up_ecn1();
  const std::string& up_ecn1() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_up_ecn1(ArgT0&& arg0, ArgT... args);
  std::string* mutable_up_ecn1();
  PROTOBUF_NODISCARD std::string* release_up_ecn1();
  void set_allocated_up_ecn1(std::string* up_ecn1);
  private:
  const std::string& _internal_up_ecn1() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_up_ecn1(const std::string& value);
  std::string* _internal_mutable_up_ecn1();
  public:

  // optional string down_dscp45 = 3;
  bool has_down_dscp45() const;
  private:
  bool _internal_has_down_dscp45() const;
  public:
  void clear_down_dscp45();
  const std::string& down_dscp45() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_down_dscp45(ArgT0&& arg0, ArgT... args);
  std::string* mutable_down_dscp45();
  PROTOBUF_NODISCARD std::string* release_down_dscp45();
  void set_allocated_down_dscp45(std::string* down_dscp45);
  private:
  const std::string& _internal_down_dscp45() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_down_dscp45(const std::string& value);
  std::string* _internal_mutable_down_dscp45();
  public:

  // @@protoc_insertion_point(class_scope:CMsgTOSTreatment)
 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 l4s_detect_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr up_ecn1_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr down_dscp45_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_steamdatagram_5fmessages_5fsdr_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CMsgSteamDatagramClientPingSampleRequest& operator=(const CMsgSteamDatagramClientPingSampleRequest& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgSteamDatagramClientPingSampleRequest& operator=(CMsgSteamDatagramClientPingSampleRequest&& 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 CMsgSteamDatagramClientPingSampleRequest& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgSteamDatagramClientPingSampleRequest* internal_default_instance() {
    return reinterpret_cast<const CMsgSteamDatagramClientPingSampleRequest*>(
               &_CMsgSteamDatagramClientPingSampleRequest_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    11;

  friend void swap(CMsgSteamDatagramClientPingSampleRequest& a, CMsgSteamDatagramClientPingSampleRequest& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgSteamDatagramClientPingSampleRequest* 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(CMsgSteamDatagramClientPingSampleRequest* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CMsgSteamDatagramClientPingSampleRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgSteamDatagramClientPingSampleRequest>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgSteamDatagramClientPingSampleRequest& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgSteamDatagramClientPingSampleRequest& from) {
    CMsgSteamDatagramClientPingSampleRequest::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(CMsgSteamDatagramClientPingSampleRequest* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgSteamDatagramClientPingSampleRequest";
  }
  protected:
  explicit CMsgSteamDatagramClientPingSampleRequest(::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 {
    kConnectionIdFieldNumber = 1,
  };
  // optional fixed32 connection_id = 1;
  bool has_connection_id() const;
  private:
  bool _internal_has_connection_id() const;
  public:
  void clear_connection_id();
  uint32_t connection_id() const;
  void set_connection_id(uint32_t value);
  private:
  uint32_t _internal_connection_id() const;
  void _internal_set_connection_id(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgSteamDatagramClientPingSampleRequest)
 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 connection_id_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_steamdatagram_5fmessages_5fsdr_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CMsgSteamDatagramClientPingSampleReply_POP_AltAddress& operator=(const CMsgSteamDatagramClientPingSampleReply_POP_AltAddress& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgSteamDatagramClientPingSampleReply_POP_AltAddress& operator=(CMsgSteamDatagramClientPingSampleReply_POP_AltAddress&& 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 CMsgSteamDatagramClientPingSampleReply_POP_AltAddress& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgSteamDatagramClientPingSampleReply_POP_AltAddress* internal_default_instance() {
    return reinterpret_cast<const CMsgSteamDatagramClientPingSampleReply_POP_AltAddress*>(
               &_CMsgSteamDatagramClientPingSampleReply_POP_AltAddress_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    12;

  friend void swap(CMsgSteamDatagramClientPingSampleReply_POP_AltAddress& a, CMsgSteamDatagramClientPingSampleReply_POP_AltAddress& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgSteamDatagramClientPingSampleReply_POP_AltAddress* 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(CMsgSteamDatagramClientPingSampleReply_POP_AltAddress* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CMsgSteamDatagramClientPingSampleReply_POP_AltAddress* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgSteamDatagramClientPingSampleReply_POP_AltAddress>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgSteamDatagramClientPingSampleReply_POP_AltAddress& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgSteamDatagramClientPingSampleReply_POP_AltAddress& from) {
    CMsgSteamDatagramClientPingSampleReply_POP_AltAddress::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(CMsgSteamDatagramClientPingSampleReply_POP_AltAddress* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgSteamDatagramClientPingSampleReply.POP.AltAddress";
  }
  protected:
  explicit CMsgSteamDatagramClientPingSampleReply_POP_AltAddress(::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 {
    kIdFieldNumber = 1,
    kFrontPingMsFieldNumber = 2,
    kPenaltyFieldNumber = 3,
  };
  // optional string id = 1;
  bool has_id() const;
  private:
  bool _internal_has_id() const;
  public:
  void clear_id();
  const std::string& id() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_id(ArgT0&& arg0, ArgT... args);
  std::string* mutable_id();
  PROTOBUF_NODISCARD std::string* release_id();
  void set_allocated_id(std::string* id);
  private:
  const std::string& _internal_id() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_id(const std::string& value);
  std::string* _internal_mutable_id();
  public:

  // optional uint32 front_ping_ms = 2;
  bool has_front_ping_ms() const;
  private:
  bool _internal_has_front_ping_ms() const;
  public:
  void clear_front_ping_ms();
  uint32_t front_ping_ms() const;
  void set_front_ping_ms(uint32_t value);
  private:
  uint32_t _internal_front_ping_ms() const;
  void _internal_set_front_ping_ms(uint32_t value);
  public:

  // optional uint32 penalty = 3;
  bool has_penalty() const;
  private:
  bool _internal_has_penalty() const;
  public:
  void clear_penalty();
  uint32_t penalty() const;
  void set_penalty(uint32_t value);
  private:
  uint32_t _internal_penalty() const;
  void _internal_set_penalty(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgSteamDatagramClientPingSampleReply.POP.AltAddress)
 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 id_;
    uint32_t front_ping_ms_;
    uint32_t penalty_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_steamdatagram_5fmessages_5fsdr_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CMsgSteamDatagramClientPingSampleReply_POP& operator=(const CMsgSteamDatagramClientPingSampleReply_POP& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgSteamDatagramClientPingSampleReply_POP& operator=(CMsgSteamDatagramClientPingSampleReply_POP&& 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 CMsgSteamDatagramClientPingSampleReply_POP& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgSteamDatagramClientPingSampleReply_POP* internal_default_instance() {
    return reinterpret_cast<const CMsgSteamDatagramClientPingSampleReply_POP*>(
               &_CMsgSteamDatagramClientPingSampleReply_POP_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    13;

  friend void swap(CMsgSteamDatagramClientPingSampleReply_POP& a, CMsgSteamDatagramClientPingSampleReply_POP& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgSteamDatagramClientPingSampleReply_POP* 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(CMsgSteamDatagramClientPingSampleReply_POP* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CMsgSteamDatagramClientPingSampleReply_POP* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgSteamDatagramClientPingSampleReply_POP>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgSteamDatagramClientPingSampleReply_POP& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgSteamDatagramClientPingSampleReply_POP& from) {
    CMsgSteamDatagramClientPingSampleReply_POP::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(CMsgSteamDatagramClientPingSampleReply_POP* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgSteamDatagramClientPingSampleReply.POP";
  }
  protected:
  explicit CMsgSteamDatagramClientPingSampleReply_POP(::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 CMsgSteamDatagramClientPingSampleReply_POP_AltAddress AltAddress;

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

  enum : int {
    kAltAddressesFieldNumber = 7,
    kPopIdFieldNumber = 1,
    kDefaultFrontPingMsFieldNumber = 2,
    kDefaultE2EPingMsFieldNumber = 3,
    kClusterPenaltyFieldNumber = 4,
    kDefaultE2EScoreFieldNumber = 5,
    kP2PViaPeerRelayPopIdFieldNumber = 6,
    kBestDcPingMsFieldNumber = 9,
    kBestDcScoreFieldNumber = 10,
    kBestDcViaRelayPopIdFieldNumber = 11,
    kDefaultDcPingMsFieldNumber = 12,
    kDefaultDcScoreFieldNumber = 13,
    kDefaultDcViaRelayPopIdFieldNumber = 14,
    kTestDcPingMsFieldNumber = 15,
    kTestDcScoreFieldNumber = 16,
    kTestDcViaRelayPopIdFieldNumber = 17,
  };
  // repeated .CMsgSteamDatagramClientPingSampleReply.POP.AltAddress alt_addresses = 7;
  int alt_addresses_size() const;
  private:
  int _internal_alt_addresses_size() const;
  public:
  void clear_alt_addresses();
  ::CMsgSteamDatagramClientPingSampleReply_POP_AltAddress* mutable_alt_addresses(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgSteamDatagramClientPingSampleReply_POP_AltAddress >*
      mutable_alt_addresses();
  private:
  const ::CMsgSteamDatagramClientPingSampleReply_POP_AltAddress& _internal_alt_addresses(int index) const;
  ::CMsgSteamDatagramClientPingSampleReply_POP_AltAddress* _internal_add_alt_addresses();
  public:
  const ::CMsgSteamDatagramClientPingSampleReply_POP_AltAddress& alt_addresses(int index) const;
  ::CMsgSteamDatagramClientPingSampleReply_POP_AltAddress* add_alt_addresses();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgSteamDatagramClientPingSampleReply_POP_AltAddress >&
      alt_addresses() const;

  // optional fixed32 pop_id = 1;
  bool has_pop_id() const;
  private:
  bool _internal_has_pop_id() const;
  public:
  void clear_pop_id();
  uint32_t pop_id() const;
  void set_pop_id(uint32_t value);
  private:
  uint32_t _internal_pop_id() const;
  void _internal_set_pop_id(uint32_t value);
  public:

  // optional uint32 default_front_ping_ms = 2;
  bool has_default_front_ping_ms() const;
  private:
  bool _internal_has_default_front_ping_ms() const;
  public:
  void clear_default_front_ping_ms();
  uint32_t default_front_ping_ms() const;
  void set_default_front_ping_ms(uint32_t value);
  private:
  uint32_t _internal_default_front_ping_ms() const;
  void _internal_set_default_front_ping_ms(uint32_t value);
  public:

  // optional uint32 default_e2e_ping_ms = 3;
  bool has_default_e2e_ping_ms() const;
  private:
  bool _internal_has_default_e2e_ping_ms() const;
  public:
  void clear_default_e2e_ping_ms();
  uint32_t default_e2e_ping_ms() const;
  void set_default_e2e_ping_ms(uint32_t value);
  private:
  uint32_t _internal_default_e2e_ping_ms() const;
  void _internal_set_default_e2e_ping_ms(uint32_t value);
  public:

  // optional uint32 cluster_penalty = 4;
  bool has_cluster_penalty() const;
  private:
  bool _internal_has_cluster_penalty() const;
  public:
  void clear_cluster_penalty();
  uint32_t cluster_penalty() const;
  void set_cluster_penalty(uint32_t value);
  private:
  uint32_t _internal_cluster_penalty() const;
  void _internal_set_cluster_penalty(uint32_t value);
  public:

  // optional uint32 default_e2e_score = 5;
  bool has_default_e2e_score() const;
  private:
  bool _internal_has_default_e2e_score() const;
  public:
  void clear_default_e2e_score();
  uint32_t default_e2e_score() const;
  void set_default_e2e_score(uint32_t value);
  private:
  uint32_t _internal_default_e2e_score() const;
  void _internal_set_default_e2e_score(uint32_t value);
  public:

  // optional fixed32 p2p_via_peer_relay_pop_id = 6;
  bool has_p2p_via_peer_relay_pop_id() const;
  private:
  bool _internal_has_p2p_via_peer_relay_pop_id() const;
  public:
  void clear_p2p_via_peer_relay_pop_id();
  uint32_t p2p_via_peer_relay_pop_id() const;
  void set_p2p_via_peer_relay_pop_id(uint32_t value);
  private:
  uint32_t _internal_p2p_via_peer_relay_pop_id() const;
  void _internal_set_p2p_via_peer_relay_pop_id(uint32_t value);
  public:

  // optional uint32 best_dc_ping_ms = 9;
  bool has_best_dc_ping_ms() const;
  private:
  bool _internal_has_best_dc_ping_ms() const;
  public:
  void clear_best_dc_ping_ms();
  uint32_t best_dc_ping_ms() const;
  void set_best_dc_ping_ms(uint32_t value);
  private:
  uint32_t _internal_best_dc_ping_ms() const;
  void _internal_set_best_dc_ping_ms(uint32_t value);
  public:

  // optional uint32 best_dc_score = 10;
  bool has_best_dc_score() const;
  private:
  bool _internal_has_best_dc_score() const;
  public:
  void clear_best_dc_score();
  uint32_t best_dc_score() const;
  void set_best_dc_score(uint32_t value);
  private:
  uint32_t _internal_best_dc_score() const;
  void _internal_set_best_dc_score(uint32_t value);
  public:

  // optional fixed32 best_dc_via_relay_pop_id = 11;
  bool has_best_dc_via_relay_pop_id() const;
  private:
  bool _internal_has_best_dc_via_relay_pop_id() const;
  public:
  void clear_best_dc_via_relay_pop_id();
  uint32_t best_dc_via_relay_pop_id() const;
  void set_best_dc_via_relay_pop_id(uint32_t value);
  private:
  uint32_t _internal_best_dc_via_relay_pop_id() const;
  void _internal_set_best_dc_via_relay_pop_id(uint32_t value);
  public:

  // optional uint32 default_dc_ping_ms = 12;
  bool has_default_dc_ping_ms() const;
  private:
  bool _internal_has_default_dc_ping_ms() const;
  public:
  void clear_default_dc_ping_ms();
  uint32_t default_dc_ping_ms() const;
  void set_default_dc_ping_ms(uint32_t value);
  private:
  uint32_t _internal_default_dc_ping_ms() const;
  void _internal_set_default_dc_ping_ms(uint32_t value);
  public:

  // optional uint32 default_dc_score = 13;
  bool has_default_dc_score() const;
  private:
  bool _internal_has_default_dc_score() const;
  public:
  void clear_default_dc_score();
  uint32_t default_dc_score() const;
  void set_default_dc_score(uint32_t value);
  private:
  uint32_t _internal_default_dc_score() const;
  void _internal_set_default_dc_score(uint32_t value);
  public:

  // optional fixed32 default_dc_via_relay_pop_id = 14;
  bool has_default_dc_via_relay_pop_id() const;
  private:
  bool _internal_has_default_dc_via_relay_pop_id() const;
  public:
  void clear_default_dc_via_relay_pop_id();
  uint32_t default_dc_via_relay_pop_id() const;
  void set_default_dc_via_relay_pop_id(uint32_t value);
  private:
  uint32_t _internal_default_dc_via_relay_pop_id() const;
  void _internal_set_default_dc_via_relay_pop_id(uint32_t value);
  public:

  // optional uint32 test_dc_ping_ms = 15;
  bool has_test_dc_ping_ms() const;
  private:
  bool _internal_has_test_dc_ping_ms() const;
  public:
  void clear_test_dc_ping_ms();
  uint32_t test_dc_ping_ms() const;
  void set_test_dc_ping_ms(uint32_t value);
  private:
  uint32_t _internal_test_dc_ping_ms() const;
  void _internal_set_test_dc_ping_ms(uint32_t value);
  public:

  // optional uint32 test_dc_score = 16;
  bool has_test_dc_score() const;
  private:
  bool _internal_has_test_dc_score() const;
  public:
  void clear_test_dc_score();
  uint32_t test_dc_score() const;
  void set_test_dc_score(uint32_t value);
  private:
  uint32_t _internal_test_dc_score() const;
  void _internal_set_test_dc_score(uint32_t value);
  public:

  // optional fixed32 test_dc_via_relay_pop_id = 17;
  bool has_test_dc_via_relay_pop_id() const;
  private:
  bool _internal_has_test_dc_via_relay_pop_id() const;
  public:
  void clear_test_dc_via_relay_pop_id();
  uint32_t test_dc_via_relay_pop_id() const;
  void set_test_dc_via_relay_pop_id(uint32_t value);
  private:
  uint32_t _internal_test_dc_via_relay_pop_id() const;
  void _internal_set_test_dc_via_relay_pop_id(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgSteamDatagramClientPingSampleReply.POP)
 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< ::CMsgSteamDatagramClientPingSampleReply_POP_AltAddress > alt_addresses_;
    uint32_t pop_id_;
    uint32_t default_front_ping_ms_;
    uint32_t default_e2e_ping_ms_;
    uint32_t cluster_penalty_;
    uint32_t default_e2e_score_;
    uint32_t p2p_via_peer_relay_pop_id_;
    uint32_t best_dc_ping_ms_;
    uint32_t best_dc_score_;
    uint32_t best_dc_via_relay_pop_id_;
    uint32_t default_dc_ping_ms_;
    uint32_t default_dc_score_;
    uint32_t default_dc_via_relay_pop_id_;
    uint32_t test_dc_ping_ms_;
    uint32_t test_dc_score_;
    uint32_t test_dc_via_relay_pop_id_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_steamdatagram_5fmessages_5fsdr_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CMsgSteamDatagramClientPingSampleReply_LegacyDataCenter& operator=(const CMsgSteamDatagramClientPingSampleReply_LegacyDataCenter& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgSteamDatagramClientPingSampleReply_LegacyDataCenter& operator=(CMsgSteamDatagramClientPingSampleReply_LegacyDataCenter&& 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 CMsgSteamDatagramClientPingSampleReply_LegacyDataCenter& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgSteamDatagramClientPingSampleReply_LegacyDataCenter* internal_default_instance() {
    return reinterpret_cast<const CMsgSteamDatagramClientPingSampleReply_LegacyDataCenter*>(
               &_CMsgSteamDatagramClientPingSampleReply_LegacyDataCenter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    14;

  friend void swap(CMsgSteamDatagramClientPingSampleReply_LegacyDataCenter& a, CMsgSteamDatagramClientPingSampleReply_LegacyDataCenter& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgSteamDatagramClientPingSampleReply_LegacyDataCenter* 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(CMsgSteamDatagramClientPingSampleReply_LegacyDataCenter* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CMsgSteamDatagramClientPingSampleReply_LegacyDataCenter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgSteamDatagramClientPingSampleReply_LegacyDataCenter>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgSteamDatagramClientPingSampleReply_LegacyDataCenter& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgSteamDatagramClientPingSampleReply_LegacyDataCenter& from) {
    CMsgSteamDatagramClientPingSampleReply_LegacyDataCenter::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(CMsgSteamDatagramClientPingSampleReply_LegacyDataCenter* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgSteamDatagramClientPingSampleReply.LegacyDataCenter";
  }
  protected:
  explicit CMsgSteamDatagramClientPingSampleReply_LegacyDataCenter(::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 {
    kDataCenterIdFieldNumber = 1,
    kBestDcViaRelayPopIdFieldNumber = 2,
    kBestDcPingMsFieldNumber = 3,
  };
  // optional fixed32 data_center_id = 1;
  bool has_data_center_id() const;
  private:
  bool _internal_has_data_center_id() const;
  public:
  void clear_data_center_id();
  uint32_t data_center_id() const;
  void set_data_center_id(uint32_t value);
  private:
  uint32_t _internal_data_center_id() const;
  void _internal_set_data_center_id(uint32_t value);
  public:

  // optional fixed32 best_dc_via_relay_pop_id = 2;
  bool has_best_dc_via_relay_pop_id() const;
  private:
  bool _internal_has_best_dc_via_relay_pop_id() const;
  public:
  void clear_best_dc_via_relay_pop_id();
  uint32_t best_dc_via_relay_pop_id() const;
  void set_best_dc_via_relay_pop_id(uint32_t value);
  private:
  uint32_t _internal_best_dc_via_relay_pop_id() const;
  void _internal_set_best_dc_via_relay_pop_id(uint32_t value);
  public:

  // optional uint32 best_dc_ping_ms = 3;
  bool has_best_dc_ping_ms() const;
  private:
  bool _internal_has_best_dc_ping_ms() const;
  public:
  void clear_best_dc_ping_ms();
  uint32_t best_dc_ping_ms() const;
  void set_best_dc_ping_ms(uint32_t value);
  private:
  uint32_t _internal_best_dc_ping_ms() const;
  void _internal_set_best_dc_ping_ms(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgSteamDatagramClientPingSampleReply.LegacyDataCenter)
 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 data_center_id_;
    uint32_t best_dc_via_relay_pop_id_;
    uint32_t best_dc_ping_ms_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_steamdatagram_5fmessages_5fsdr_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CMsgSteamDatagramClientPingSampleReply& operator=(const CMsgSteamDatagramClientPingSampleReply& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgSteamDatagramClientPingSampleReply& operator=(CMsgSteamDatagramClientPingSampleReply&& 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 CMsgSteamDatagramClientPingSampleReply& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgSteamDatagramClientPingSampleReply* internal_default_instance() {
    return reinterpret_cast<const CMsgSteamDatagramClientPingSampleReply*>(
               &_CMsgSteamDatagramClientPingSampleReply_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    15;

  friend void swap(CMsgSteamDatagramClientPingSampleReply& a, CMsgSteamDatagramClientPingSampleReply& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgSteamDatagramClientPingSampleReply* 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(CMsgSteamDatagramClientPingSampleReply* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CMsgSteamDatagramClientPingSampleReply* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgSteamDatagramClientPingSampleReply>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgSteamDatagramClientPingSampleReply& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgSteamDatagramClientPingSampleReply& from) {
    CMsgSteamDatagramClientPingSampleReply::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(CMsgSteamDatagramClientPingSampleReply* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgSteamDatagramClientPingSampleReply";
  }
  protected:
  explicit CMsgSteamDatagramClientPingSampleReply(::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 CMsgSteamDatagramClientPingSampleReply_POP POP;
  typedef CMsgSteamDatagramClientPingSampleReply_LegacyDataCenter LegacyDataCenter;

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

  enum : int {
    kPopsFieldNumber = 2,
    kLegacyDataCentersFieldNumber = 3,
    kTosFieldNumber = 6,
    kConnectionIdFieldNumber = 1,
    kRelayOverrideActiveFieldNumber = 5,
  };
  // repeated .CMsgSteamDatagramClientPingSampleReply.POP pops = 2;
  int pops_size() const;
  private:
  int _internal_pops_size() const;
  public:
  void clear_pops();
  ::CMsgSteamDatagramClientPingSampleReply_POP* mutable_pops(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgSteamDatagramClientPingSampleReply_POP >*
      mutable_pops();
  private:
  const ::CMsgSteamDatagramClientPingSampleReply_POP& _internal_pops(int index) const;
  ::CMsgSteamDatagramClientPingSampleReply_POP* _internal_add_pops();
  public:
  const ::CMsgSteamDatagramClientPingSampleReply_POP& pops(int index) const;
  ::CMsgSteamDatagramClientPingSampleReply_POP* add_pops();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgSteamDatagramClientPingSampleReply_POP >&
      pops() const;

  // repeated .CMsgSteamDatagramClientPingSampleReply.LegacyDataCenter legacy_data_centers = 3;
  int legacy_data_centers_size() const;
  private:
  int _internal_legacy_data_centers_size() const;
  public:
  void clear_legacy_data_centers();
  ::CMsgSteamDatagramClientPingSampleReply_LegacyDataCenter* mutable_legacy_data_centers(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgSteamDatagramClientPingSampleReply_LegacyDataCenter >*
      mutable_legacy_data_centers();
  private:
  const ::CMsgSteamDatagramClientPingSampleReply_LegacyDataCenter& _internal_legacy_data_centers(int index) const;
  ::CMsgSteamDatagramClientPingSampleReply_LegacyDataCenter* _internal_add_legacy_data_centers();
  public:
  const ::CMsgSteamDatagramClientPingSampleReply_LegacyDataCenter& legacy_data_centers(int index) const;
  ::CMsgSteamDatagramClientPingSampleReply_LegacyDataCenter* add_legacy_data_centers();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgSteamDatagramClientPingSampleReply_LegacyDataCenter >&
      legacy_data_centers() const;

  // optional .CMsgTOSTreatment tos = 6;
  bool has_tos() const;
  private:
  bool _internal_has_tos() const;
  public:
  void clear_tos();
  const ::CMsgTOSTreatment& tos() const;
  PROTOBUF_NODISCARD ::CMsgTOSTreatment* release_tos();
  ::CMsgTOSTreatment* mutable_tos();
  void set_allocated_tos(::CMsgTOSTreatment* tos);
  private:
  const ::CMsgTOSTreatment& _internal_tos() const;
  ::CMsgTOSTreatment* _internal_mutable_tos();
  public:
  void unsafe_arena_set_allocated_tos(
      ::CMsgTOSTreatment* tos);
  ::CMsgTOSTreatment* unsafe_arena_release_tos();

  // optional fixed32 connection_id = 1;
  bool has_connection_id() const;
  private:
  bool _internal_has_connection_id() const;
  public:
  void clear_connection_id();
  uint32_t connection_id() const;
  void set_connection_id(uint32_t value);
  private:
  uint32_t _internal_connection_id() const;
  void _internal_set_connection_id(uint32_t value);
  public:

  // optional bool relay_override_active = 5;
  bool has_relay_override_active() const;
  private:
  bool _internal_has_relay_override_active() const;
  public:
  void clear_relay_override_active();
  bool relay_override_active() const;
  void set_relay_override_active(bool value);
  private:
  bool _internal_relay_override_active() const;
  void _internal_set_relay_override_active(bool value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgSteamDatagramClientPingSampleReply)
 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< ::CMsgSteamDatagramClientPingSampleReply_POP > pops_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgSteamDatagramClientPingSampleReply_LegacyDataCenter > legacy_data_centers_;
    ::CMsgTOSTreatment* tos_;
    uint32_t connection_id_;
    bool relay_override_active_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_steamdatagram_5fmessages_5fsdr_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CMsgSteamDatagramClientSwitchedPrimary_RouterQuality& operator=(const CMsgSteamDatagramClientSwitchedPrimary_RouterQuality& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgSteamDatagramClientSwitchedPrimary_RouterQuality& operator=(CMsgSteamDatagramClientSwitchedPrimary_RouterQuality&& 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 CMsgSteamDatagramClientSwitchedPrimary_RouterQuality& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgSteamDatagramClientSwitchedPrimary_RouterQuality* internal_default_instance() {
    return reinterpret_cast<const CMsgSteamDatagramClientSwitchedPrimary_RouterQuality*>(
               &_CMsgSteamDatagramClientSwitchedPrimary_RouterQuality_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    16;

  friend void swap(CMsgSteamDatagramClientSwitchedPrimary_RouterQuality& a, CMsgSteamDatagramClientSwitchedPrimary_RouterQuality& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgSteamDatagramClientSwitchedPrimary_RouterQuality* 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(CMsgSteamDatagramClientSwitchedPrimary_RouterQuality* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CMsgSteamDatagramClientSwitchedPrimary_RouterQuality* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgSteamDatagramClientSwitchedPrimary_RouterQuality>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgSteamDatagramClientSwitchedPrimary_RouterQuality& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgSteamDatagramClientSwitchedPrimary_RouterQuality& from) {
    CMsgSteamDatagramClientSwitchedPrimary_RouterQuality::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(CMsgSteamDatagramClientSwitchedPrimary_RouterQuality* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgSteamDatagramClientSwitchedPrimary.RouterQuality";
  }
  protected:
  explicit CMsgSteamDatagramClientSwitchedPrimary_RouterQuality(::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 {
    kScoreFieldNumber = 1,
    kFrontPingFieldNumber = 2,
    kBackPingFieldNumber = 3,
    kSecondsUntilDownFieldNumber = 4,
  };
  // optional uint32 score = 1;
  bool has_score() const;
  private:
  bool _internal_has_score() const;
  public:
  void clear_score();
  uint32_t score() const;
  void set_score(uint32_t value);
  private:
  uint32_t _internal_score() const;
  void _internal_set_score(uint32_t value);
  public:

  // optional uint32 front_ping = 2;
  bool has_front_ping() const;
  private:
  bool _internal_has_front_ping() const;
  public:
  void clear_front_ping();
  uint32_t front_ping() const;
  void set_front_ping(uint32_t value);
  private:
  uint32_t _internal_front_ping() const;
  void _internal_set_front_ping(uint32_t value);
  public:

  // optional uint32 back_ping = 3;
  bool has_back_ping() const;
  private:
  bool _internal_has_back_ping() const;
  public:
  void clear_back_ping();
  uint32_t back_ping() const;
  void set_back_ping(uint32_t value);
  private:
  uint32_t _internal_back_ping() const;
  void _internal_set_back_ping(uint32_t value);
  public:

  // optional uint32 seconds_until_down = 4;
  bool has_seconds_until_down() const;
  private:
  bool _internal_has_seconds_until_down() const;
  public:
  void clear_seconds_until_down();
  uint32_t seconds_until_down() const;
  void set_seconds_until_down(uint32_t value);
  private:
  uint32_t _internal_seconds_until_down() const;
  void _internal_set_seconds_until_down(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgSteamDatagramClientSwitchedPrimary.RouterQuality)
 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 score_;
    uint32_t front_ping_;
    uint32_t back_ping_;
    uint32_t seconds_until_down_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_steamdatagram_5fmessages_5fsdr_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CMsgSteamDatagramClientSwitchedPrimary& operator=(const CMsgSteamDatagramClientSwitchedPrimary& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgSteamDatagramClientSwitchedPrimary& operator=(CMsgSteamDatagramClientSwitchedPrimary&& 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 CMsgSteamDatagramClientSwitchedPrimary& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgSteamDatagramClientSwitchedPrimary* internal_default_instance() {
    return reinterpret_cast<const CMsgSteamDatagramClientSwitchedPrimary*>(
               &_CMsgSteamDatagramClientSwitchedPrimary_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    17;

  friend void swap(CMsgSteamDatagramClientSwitchedPrimary& a, CMsgSteamDatagramClientSwitchedPrimary& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgSteamDatagramClientSwitchedPrimary* 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(CMsgSteamDatagramClientSwitchedPrimary* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CMsgSteamDatagramClientSwitchedPrimary* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgSteamDatagramClientSwitchedPrimary>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgSteamDatagramClientSwitchedPrimary& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgSteamDatagramClientSwitchedPrimary& from) {
    CMsgSteamDatagramClientSwitchedPrimary::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(CMsgSteamDatagramClientSwitchedPrimary* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgSteamDatagramClientSwitchedPrimary";
  }
  protected:
  explicit CMsgSteamDatagramClientSwitchedPrimary(::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 CMsgSteamDatagramClientSwitchedPrimary_RouterQuality RouterQuality;

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

  enum : int {
    kFromDroppedReasonFieldNumber = 7,
    kFromQualityNowFieldNumber = 9,
    kToQualityNowFieldNumber = 10,
    kFromQualityThenFieldNumber = 11,
    kToQualityThenFieldNumber = 12,
    kConnectionIdFieldNumber = 1,
    kFromIpFieldNumber = 2,
    kFromPortFieldNumber = 3,
    kFromRouterClusterFieldNumber = 4,
    kFromActiveTimeFieldNumber = 5,
    kFromActivePacketsRecvFieldNumber = 6,
    kGapMsFieldNumber = 8,
  };
  // optional string from_dropped_reason = 7;
  bool has_from_dropped_reason() const;
  private:
  bool _internal_has_from_dropped_reason() const;
  public:
  void clear_from_dropped_reason();
  const std::string& from_dropped_reason() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_from_dropped_reason(ArgT0&& arg0, ArgT... args);
  std::string* mutable_from_dropped_reason();
  PROTOBUF_NODISCARD std::string* release_from_dropped_reason();
  void set_allocated_from_dropped_reason(std::string* from_dropped_reason);
  private:
  const std::string& _internal_from_dropped_reason() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_from_dropped_reason(const std::string& value);
  std::string* _internal_mutable_from_dropped_reason();
  public:

  // optional .CMsgSteamDatagramClientSwitchedPrimary.RouterQuality from_quality_now = 9;
  bool has_from_quality_now() const;
  private:
  bool _internal_has_from_quality_now() const;
  public:
  void clear_from_quality_now();
  const ::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality& from_quality_now() const;
  PROTOBUF_NODISCARD ::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality* release_from_quality_now();
  ::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality* mutable_from_quality_now();
  void set_allocated_from_quality_now(::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality* from_quality_now);
  private:
  const ::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality& _internal_from_quality_now() const;
  ::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality* _internal_mutable_from_quality_now();
  public:
  void unsafe_arena_set_allocated_from_quality_now(
      ::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality* from_quality_now);
  ::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality* unsafe_arena_release_from_quality_now();

  // optional .CMsgSteamDatagramClientSwitchedPrimary.RouterQuality to_quality_now = 10;
  bool has_to_quality_now() const;
  private:
  bool _internal_has_to_quality_now() const;
  public:
  void clear_to_quality_now();
  const ::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality& to_quality_now() const;
  PROTOBUF_NODISCARD ::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality* release_to_quality_now();
  ::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality* mutable_to_quality_now();
  void set_allocated_to_quality_now(::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality* to_quality_now);
  private:
  const ::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality& _internal_to_quality_now() const;
  ::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality* _internal_mutable_to_quality_now();
  public:
  void unsafe_arena_set_allocated_to_quality_now(
      ::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality* to_quality_now);
  ::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality* unsafe_arena_release_to_quality_now();

  // optional .CMsgSteamDatagramClientSwitchedPrimary.RouterQuality from_quality_then = 11;
  bool has_from_quality_then() const;
  private:
  bool _internal_has_from_quality_then() const;
  public:
  void clear_from_quality_then();
  const ::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality& from_quality_then() const;
  PROTOBUF_NODISCARD ::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality* release_from_quality_then();
  ::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality* mutable_from_quality_then();
  void set_allocated_from_quality_then(::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality* from_quality_then);
  private:
  const ::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality& _internal_from_quality_then() const;
  ::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality* _internal_mutable_from_quality_then();
  public:
  void unsafe_arena_set_allocated_from_quality_then(
      ::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality* from_quality_then);
  ::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality* unsafe_arena_release_from_quality_then();

  // optional .CMsgSteamDatagramClientSwitchedPrimary.RouterQuality to_quality_then = 12;
  bool has_to_quality_then() const;
  private:
  bool _internal_has_to_quality_then() const;
  public:
  void clear_to_quality_then();
  const ::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality& to_quality_then() const;
  PROTOBUF_NODISCARD ::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality* release_to_quality_then();
  ::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality* mutable_to_quality_then();
  void set_allocated_to_quality_then(::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality* to_quality_then);
  private:
  const ::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality& _internal_to_quality_then() const;
  ::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality* _internal_mutable_to_quality_then();
  public:
  void unsafe_arena_set_allocated_to_quality_then(
      ::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality* to_quality_then);
  ::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality* unsafe_arena_release_to_quality_then();

  // optional fixed32 connection_id = 1;
  bool has_connection_id() const;
  private:
  bool _internal_has_connection_id() const;
  public:
  void clear_connection_id();
  uint32_t connection_id() const;
  void set_connection_id(uint32_t value);
  private:
  uint32_t _internal_connection_id() const;
  void _internal_set_connection_id(uint32_t value);
  public:

  // optional fixed32 from_ip = 2;
  bool has_from_ip() const;
  private:
  bool _internal_has_from_ip() const;
  public:
  void clear_from_ip();
  uint32_t from_ip() const;
  void set_from_ip(uint32_t value);
  private:
  uint32_t _internal_from_ip() const;
  void _internal_set_from_ip(uint32_t value);
  public:

  // optional uint32 from_port = 3;
  bool has_from_port() const;
  private:
  bool _internal_has_from_port() const;
  public:
  void clear_from_port();
  uint32_t from_port() const;
  void set_from_port(uint32_t value);
  private:
  uint32_t _internal_from_port() const;
  void _internal_set_from_port(uint32_t value);
  public:

  // optional fixed32 from_router_cluster = 4;
  bool has_from_router_cluster() const;
  private:
  bool _internal_has_from_router_cluster() const;
  public:
  void clear_from_router_cluster();
  uint32_t from_router_cluster() const;
  void set_from_router_cluster(uint32_t value);
  private:
  uint32_t _internal_from_router_cluster() const;
  void _internal_set_from_router_cluster(uint32_t value);
  public:

  // optional uint32 from_active_time = 5;
  bool has_from_active_time() const;
  private:
  bool _internal_has_from_active_time() const;
  public:
  void clear_from_active_time();
  uint32_t from_active_time() const;
  void set_from_active_time(uint32_t value);
  private:
  uint32_t _internal_from_active_time() const;
  void _internal_set_from_active_time(uint32_t value);
  public:

  // optional uint32 from_active_packets_recv = 6;
  bool has_from_active_packets_recv() const;
  private:
  bool _internal_has_from_active_packets_recv() const;
  public:
  void clear_from_active_packets_recv();
  uint32_t from_active_packets_recv() const;
  void set_from_active_packets_recv(uint32_t value);
  private:
  uint32_t _internal_from_active_packets_recv() const;
  void _internal_set_from_active_packets_recv(uint32_t value);
  public:

  // optional uint32 gap_ms = 8;
  bool has_gap_ms() const;
  private:
  bool _internal_has_gap_ms() const;
  public:
  void clear_gap_ms();
  uint32_t gap_ms() const;
  void set_gap_ms(uint32_t value);
  private:
  uint32_t _internal_gap_ms() const;
  void _internal_set_gap_ms(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgSteamDatagramClientSwitchedPrimary)
 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_dropped_reason_;
    ::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality* from_quality_now_;
    ::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality* to_quality_now_;
    ::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality* from_quality_then_;
    ::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality* to_quality_then_;
    uint32_t connection_id_;
    uint32_t from_ip_;
    uint32_t from_port_;
    uint32_t from_router_cluster_;
    uint32_t from_active_time_;
    uint32_t from_active_packets_recv_;
    uint32_t gap_ms_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_steamdatagram_5fmessages_5fsdr_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CMsgSteamDatagramConnectRequest& operator=(const CMsgSteamDatagramConnectRequest& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgSteamDatagramConnectRequest& operator=(CMsgSteamDatagramConnectRequest&& 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 CMsgSteamDatagramConnectRequest& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgSteamDatagramConnectRequest* internal_default_instance() {
    return reinterpret_cast<const CMsgSteamDatagramConnectRequest*>(
               &_CMsgSteamDatagramConnectRequest_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    18;

  friend void swap(CMsgSteamDatagramConnectRequest& a, CMsgSteamDatagramConnectRequest& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgSteamDatagramConnectRequest* 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(CMsgSteamDatagramConnectRequest* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CMsgSteamDatagramConnectRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgSteamDatagramConnectRequest>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgSteamDatagramConnectRequest& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgSteamDatagramConnectRequest& from) {
    CMsgSteamDatagramConnectRequest::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(CMsgSteamDatagramConnectRequest* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgSteamDatagramConnectRequest";
  }
  protected:
  explicit CMsgSteamDatagramConnectRequest(::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 = 6,
    kCertFieldNumber = 7,
    kConnectionIdFieldNumber = 1,
    kGameserverRelaySessionIdFieldNumber = 2,
    kLegacyClientSteamIdFieldNumber = 3,
    kMyTimestampFieldNumber = 4,
    kPingEstMsFieldNumber = 5,
    kVirtualPortFieldNumber = 9,
    kRoutingSecretFieldNumber = 10,
  };
  // 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 fixed32 connection_id = 1;
  bool has_connection_id() const;
  private:
  bool _internal_has_connection_id() const;
  public:
  void clear_connection_id();
  uint32_t connection_id() const;
  void set_connection_id(uint32_t value);
  private:
  uint32_t _internal_connection_id() const;
  void _internal_set_connection_id(uint32_t value);
  public:

  // optional uint32 gameserver_relay_session_id = 2;
  bool has_gameserver_relay_session_id() const;
  private:
  bool _internal_has_gameserver_relay_session_id() const;
  public:
  void clear_gameserver_relay_session_id();
  uint32_t gameserver_relay_session_id() const;
  void set_gameserver_relay_session_id(uint32_t value);
  private:
  uint32_t _internal_gameserver_relay_session_id() const;
  void _internal_set_gameserver_relay_session_id(uint32_t value);
  public:

  // optional fixed64 legacy_client_steam_id = 3;
  bool has_legacy_client_steam_id() const;
  private:
  bool _internal_has_legacy_client_steam_id() const;
  public:
  void clear_legacy_client_steam_id();
  uint64_t legacy_client_steam_id() const;
  void set_legacy_client_steam_id(uint64_t value);
  private:
  uint64_t _internal_legacy_client_steam_id() const;
  void _internal_set_legacy_client_steam_id(uint64_t value);
  public:

  // optional fixed64 my_timestamp = 4;
  bool has_my_timestamp() const;
  private:
  bool _internal_has_my_timestamp() const;
  public:
  void clear_my_timestamp();
  uint64_t my_timestamp() const;
  void set_my_timestamp(uint64_t value);
  private:
  uint64_t _internal_my_timestamp() const;
  void _internal_set_my_timestamp(uint64_t value);
  public:

  // optional uint32 ping_est_ms = 5;
  bool has_ping_est_ms() const;
  private:
  bool _internal_has_ping_est_ms() const;
  public:
  void clear_ping_est_ms();
  uint32_t ping_est_ms() const;
  void set_ping_est_ms(uint32_t value);
  private:
  uint32_t _internal_ping_est_ms() const;
  void _internal_set_ping_est_ms(uint32_t value);
  public:

  // optional uint32 virtual_port = 9;
  bool has_virtual_port() const;
  private:
  bool _internal_has_virtual_port() const;
  public:
  void clear_virtual_port();
  uint32_t virtual_port() const;
  void set_virtual_port(uint32_t value);
  private:
  uint32_t _internal_virtual_port() const;
  void _internal_set_virtual_port(uint32_t value);
  public:

  // optional fixed64 routing_secret = 10;
  bool has_routing_secret() const;
  private:
  bool _internal_has_routing_secret() const;
  public:
  void clear_routing_secret();
  uint64_t routing_secret() const;
  void set_routing_secret(uint64_t value);
  private:
  uint64_t _internal_routing_secret() const;
  void _internal_set_routing_secret(uint64_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgSteamDatagramConnectRequest)
 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_;
    uint32_t connection_id_;
    uint32_t gameserver_relay_session_id_;
    uint64_t legacy_client_steam_id_;
    uint64_t my_timestamp_;
    uint32_t ping_est_ms_;
    uint32_t virtual_port_;
    uint64_t routing_secret_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_steamdatagram_5fmessages_5fsdr_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CMsgSteamDatagramConnectOK& operator=(const CMsgSteamDatagramConnectOK& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgSteamDatagramConnectOK& operator=(CMsgSteamDatagramConnectOK&& 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 CMsgSteamDatagramConnectOK& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgSteamDatagramConnectOK* internal_default_instance() {
    return reinterpret_cast<const CMsgSteamDatagramConnectOK*>(
               &_CMsgSteamDatagramConnectOK_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    19;

  friend void swap(CMsgSteamDatagramConnectOK& a, CMsgSteamDatagramConnectOK& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgSteamDatagramConnectOK* 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(CMsgSteamDatagramConnectOK* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CMsgSteamDatagramConnectOK* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgSteamDatagramConnectOK>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgSteamDatagramConnectOK& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgSteamDatagramConnectOK& from) {
    CMsgSteamDatagramConnectOK::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(CMsgSteamDatagramConnectOK* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgSteamDatagramConnectOK";
  }
  protected:
  explicit CMsgSteamDatagramConnectOK(::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,
    kClientConnectionIdFieldNumber = 1,
    kGameserverRelaySessionIdFieldNumber = 2,
    kYourTimestampFieldNumber = 3,
    kDelayTimeUsecFieldNumber = 4,
    kServerConnectionIdFieldNumber = 7,
  };
  // 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();

  // optional fixed32 client_connection_id = 1;
  bool has_client_connection_id() const;
  private:
  bool _internal_has_client_connection_id() const;
  public:
  void clear_client_connection_id();
  uint32_t client_connection_id() const;
  void set_client_connection_id(uint32_t value);
  private:
  uint32_t _internal_client_connection_id() const;
  void _internal_set_client_connection_id(uint32_t value);
  public:

  // optional uint32 gameserver_relay_session_id = 2;
  bool has_gameserver_relay_session_id() const;
  private:
  bool _internal_has_gameserver_relay_session_id() const;
  public:
  void clear_gameserver_relay_session_id();
  uint32_t gameserver_relay_session_id() const;
  void set_gameserver_relay_session_id(uint32_t value);
  private:
  uint32_t _internal_gameserver_relay_session_id() const;
  void _internal_set_gameserver_relay_session_id(uint32_t value);
  public:

  // optional fixed64 your_timestamp = 3;
  bool has_your_timestamp() const;
  private:
  bool _internal_has_your_timestamp() const;
  public:
  void clear_your_timestamp();
  uint64_t your_timestamp() const;
  void set_your_timestamp(uint64_t value);
  private:
  uint64_t _internal_your_timestamp() const;
  void _internal_set_your_timestamp(uint64_t value);
  public:

  // optional uint32 delay_time_usec = 4;
  bool has_delay_time_usec() const;
  private:
  bool _internal_has_delay_time_usec() const;
  public:
  void clear_delay_time_usec();
  uint32_t delay_time_usec() const;
  void set_delay_time_usec(uint32_t value);
  private:
  uint32_t _internal_delay_time_usec() const;
  void _internal_set_delay_time_usec(uint32_t value);
  public:

  // optional fixed32 server_connection_id = 7;
  bool has_server_connection_id() const;
  private:
  bool _internal_has_server_connection_id() const;
  public:
  void clear_server_connection_id();
  uint32_t server_connection_id() const;
  void set_server_connection_id(uint32_t value);
  private:
  uint32_t _internal_server_connection_id() const;
  void _internal_set_server_connection_id(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgSteamDatagramConnectOK)
 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_;
    uint32_t client_connection_id_;
    uint32_t gameserver_relay_session_id_;
    uint64_t your_timestamp_;
    uint32_t delay_time_usec_;
    uint32_t server_connection_id_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_steamdatagram_5fmessages_5fsdr_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CMsgSteamNetworkingP2PSDRRoutingSummary& operator=(const CMsgSteamNetworkingP2PSDRRoutingSummary& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgSteamNetworkingP2PSDRRoutingSummary& operator=(CMsgSteamNetworkingP2PSDRRoutingSummary&& 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 CMsgSteamNetworkingP2PSDRRoutingSummary& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgSteamNetworkingP2PSDRRoutingSummary* internal_default_instance() {
    return reinterpret_cast<const CMsgSteamNetworkingP2PSDRRoutingSummary*>(
               &_CMsgSteamNetworkingP2PSDRRoutingSummary_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    20;

  friend void swap(CMsgSteamNetworkingP2PSDRRoutingSummary& a, CMsgSteamNetworkingP2PSDRRoutingSummary& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgSteamNetworkingP2PSDRRoutingSummary* 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(CMsgSteamNetworkingP2PSDRRoutingSummary* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CMsgSteamNetworkingP2PSDRRoutingSummary* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgSteamNetworkingP2PSDRRoutingSummary>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgSteamNetworkingP2PSDRRoutingSummary& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgSteamNetworkingP2PSDRRoutingSummary& from) {
    CMsgSteamNetworkingP2PSDRRoutingSummary::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(CMsgSteamNetworkingP2PSDRRoutingSummary* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgSteamNetworkingP2PSDRRoutingSummary";
  }
  protected:
  explicit CMsgSteamNetworkingP2PSDRRoutingSummary(::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 {
    kInitialPingFieldNumber = 1,
    kInitialPingFrontLocalFieldNumber = 2,
    kInitialPingFrontRemoteFieldNumber = 3,
    kInitialScoreFieldNumber = 4,
    kInitialPopLocalFieldNumber = 5,
    kInitialPopRemoteFieldNumber = 6,
    kNegotiationMsFieldNumber = 7,
    kSelectedSecondsFieldNumber = 8,
    kBestPingFieldNumber = 11,
    kBestPingFrontLocalFieldNumber = 12,
    kBestPingFrontRemoteFieldNumber = 13,
    kBestScoreFieldNumber = 14,
    kBestPopLocalFieldNumber = 15,
    kBestPopRemoteFieldNumber = 16,
    kBestTimeFieldNumber = 17,
  };
  // optional uint32 initial_ping = 1;
  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 initial_ping_front_local = 2;
  bool has_initial_ping_front_local() const;
  private:
  bool _internal_has_initial_ping_front_local() const;
  public:
  void clear_initial_ping_front_local();
  uint32_t initial_ping_front_local() const;
  void set_initial_ping_front_local(uint32_t value);
  private:
  uint32_t _internal_initial_ping_front_local() const;
  void _internal_set_initial_ping_front_local(uint32_t value);
  public:

  // optional uint32 initial_ping_front_remote = 3;
  bool has_initial_ping_front_remote() const;
  private:
  bool _internal_has_initial_ping_front_remote() const;
  public:
  void clear_initial_ping_front_remote();
  uint32_t initial_ping_front_remote() const;
  void set_initial_ping_front_remote(uint32_t value);
  private:
  uint32_t _internal_initial_ping_front_remote() const;
  void _internal_set_initial_ping_front_remote(uint32_t value);
  public:

  // optional uint32 initial_score = 4;
  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 fixed32 initial_pop_local = 5;
  bool has_initial_pop_local() const;
  private:
  bool _internal_has_initial_pop_local() const;
  public:
  void clear_initial_pop_local();
  uint32_t initial_pop_local() const;
  void set_initial_pop_local(uint32_t value);
  private:
  uint32_t _internal_initial_pop_local() const;
  void _internal_set_initial_pop_local(uint32_t value);
  public:

  // optional fixed32 initial_pop_remote = 6;
  bool has_initial_pop_remote() const;
  private:
  bool _internal_has_initial_pop_remote() const;
  public:
  void clear_initial_pop_remote();
  uint32_t initial_pop_remote() const;
  void set_initial_pop_remote(uint32_t value);
  private:
  uint32_t _internal_initial_pop_remote() const;
  void _internal_set_initial_pop_remote(uint32_t value);
  public:

  // optional uint32 negotiation_ms = 7;
  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 selected_seconds = 8;
  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 best_ping = 11;
  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_ping_front_local = 12;
  bool has_best_ping_front_local() const;
  private:
  bool _internal_has_best_ping_front_local() const;
  public:
  void clear_best_ping_front_local();
  uint32_t best_ping_front_local() const;
  void set_best_ping_front_local(uint32_t value);
  private:
  uint32_t _internal_best_ping_front_local() const;
  void _internal_set_best_ping_front_local(uint32_t value);
  public:

  // optional uint32 best_ping_front_remote = 13;
  bool has_best_ping_front_remote() const;
  private:
  bool _internal_has_best_ping_front_remote() const;
  public:
  void clear_best_ping_front_remote();
  uint32_t best_ping_front_remote() const;
  void set_best_ping_front_remote(uint32_t value);
  private:
  uint32_t _internal_best_ping_front_remote() const;
  void _internal_set_best_ping_front_remote(uint32_t value);
  public:

  // optional uint32 best_score = 14;
  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 fixed32 best_pop_local = 15;
  bool has_best_pop_local() const;
  private:
  bool _internal_has_best_pop_local() const;
  public:
  void clear_best_pop_local();
  uint32_t best_pop_local() const;
  void set_best_pop_local(uint32_t value);
  private:
  uint32_t _internal_best_pop_local() const;
  void _internal_set_best_pop_local(uint32_t value);
  public:

  // optional fixed32 best_pop_remote = 16;
  bool has_best_pop_remote() const;
  private:
  bool _internal_has_best_pop_remote() const;
  public:
  void clear_best_pop_remote();
  uint32_t best_pop_remote() const;
  void set_best_pop_remote(uint32_t value);
  private:
  uint32_t _internal_best_pop_remote() const;
  void _internal_set_best_pop_remote(uint32_t value);
  public:

  // optional uint32 best_time = 17;
  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:CMsgSteamNetworkingP2PSDRRoutingSummary)
 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 initial_ping_;
    uint32_t initial_ping_front_local_;
    uint32_t initial_ping_front_remote_;
    uint32_t initial_score_;
    uint32_t initial_pop_local_;
    uint32_t initial_pop_remote_;
    uint32_t negotiation_ms_;
    uint32_t selected_seconds_;
    uint32_t best_ping_;
    uint32_t best_ping_front_local_;
    uint32_t best_ping_front_remote_;
    uint32_t best_score_;
    uint32_t best_pop_local_;
    uint32_t best_pop_remote_;
    uint32_t best_time_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_steamdatagram_5fmessages_5fsdr_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CMsgSteamDatagramP2PRoutingSummary& operator=(const CMsgSteamDatagramP2PRoutingSummary& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgSteamDatagramP2PRoutingSummary& operator=(CMsgSteamDatagramP2PRoutingSummary&& 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 CMsgSteamDatagramP2PRoutingSummary& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgSteamDatagramP2PRoutingSummary* internal_default_instance() {
    return reinterpret_cast<const CMsgSteamDatagramP2PRoutingSummary*>(
               &_CMsgSteamDatagramP2PRoutingSummary_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    21;

  friend void swap(CMsgSteamDatagramP2PRoutingSummary& a, CMsgSteamDatagramP2PRoutingSummary& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgSteamDatagramP2PRoutingSummary* 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(CMsgSteamDatagramP2PRoutingSummary* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CMsgSteamDatagramP2PRoutingSummary* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgSteamDatagramP2PRoutingSummary>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgSteamDatagramP2PRoutingSummary& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgSteamDatagramP2PRoutingSummary& from) {
    CMsgSteamDatagramP2PRoutingSummary::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(CMsgSteamDatagramP2PRoutingSummary* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgSteamDatagramP2PRoutingSummary";
  }
  protected:
  explicit CMsgSteamDatagramP2PRoutingSummary(::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 = 2,
    kSdrFieldNumber = 3,
  };
  // optional .CMsgSteamNetworkingICESessionSummary ice = 2;
  bool has_ice() const;
  private:
  bool _internal_has_ice() const;
  public:
  void clear_ice();
  const ::CMsgSteamNetworkingICESessionSummary& ice() const;
  PROTOBUF_NODISCARD ::CMsgSteamNetworkingICESessionSummary* release_ice();
  ::CMsgSteamNetworkingICESessionSummary* mutable_ice();
  void set_allocated_ice(::CMsgSteamNetworkingICESessionSummary* ice);
  private:
  const ::CMsgSteamNetworkingICESessionSummary& _internal_ice() const;
  ::CMsgSteamNetworkingICESessionSummary* _internal_mutable_ice();
  public:
  void unsafe_arena_set_allocated_ice(
      ::CMsgSteamNetworkingICESessionSummary* ice);
  ::CMsgSteamNetworkingICESessionSummary* unsafe_arena_release_ice();

  // optional .CMsgSteamNetworkingP2PSDRRoutingSummary sdr = 3;
  bool has_sdr() const;
  private:
  bool _internal_has_sdr() const;
  public:
  void clear_sdr();
  const ::CMsgSteamNetworkingP2PSDRRoutingSummary& sdr() const;
  PROTOBUF_NODISCARD ::CMsgSteamNetworkingP2PSDRRoutingSummary* release_sdr();
  ::CMsgSteamNetworkingP2PSDRRoutingSummary* mutable_sdr();
  void set_allocated_sdr(::CMsgSteamNetworkingP2PSDRRoutingSummary* sdr);
  private:
  const ::CMsgSteamNetworkingP2PSDRRoutingSummary& _internal_sdr() const;
  ::CMsgSteamNetworkingP2PSDRRoutingSummary* _internal_mutable_sdr();
  public:
  void unsafe_arena_set_allocated_sdr(
      ::CMsgSteamNetworkingP2PSDRRoutingSummary* sdr);
  ::CMsgSteamNetworkingP2PSDRRoutingSummary* unsafe_arena_release_sdr();

  // @@protoc_insertion_point(class_scope:CMsgSteamDatagramP2PRoutingSummary)
 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_;
    ::CMsgSteamNetworkingICESessionSummary* ice_;
    ::CMsgSteamNetworkingP2PSDRRoutingSummary* sdr_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_steamdatagram_5fmessages_5fsdr_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CMsgSteamDatagramConnectionClosed& operator=(const CMsgSteamDatagramConnectionClosed& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgSteamDatagramConnectionClosed& operator=(CMsgSteamDatagramConnectionClosed&& 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 CMsgSteamDatagramConnectionClosed& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgSteamDatagramConnectionClosed* internal_default_instance() {
    return reinterpret_cast<const CMsgSteamDatagramConnectionClosed*>(
               &_CMsgSteamDatagramConnectionClosed_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    22;

  friend void swap(CMsgSteamDatagramConnectionClosed& a, CMsgSteamDatagramConnectionClosed& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgSteamDatagramConnectionClosed* 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(CMsgSteamDatagramConnectionClosed* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CMsgSteamDatagramConnectionClosed* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgSteamDatagramConnectionClosed>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgSteamDatagramConnectionClosed& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgSteamDatagramConnectionClosed& from) {
    CMsgSteamDatagramConnectionClosed::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(CMsgSteamDatagramConnectionClosed* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgSteamDatagramConnectionClosed";
  }
  protected:
  explicit CMsgSteamDatagramConnectionClosed(::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 CMsgSteamDatagramConnectionClosed_ERelayMode ERelayMode;
  static constexpr ERelayMode None =
    CMsgSteamDatagramConnectionClosed_ERelayMode_None;
  static constexpr ERelayMode EndToEnd =
    CMsgSteamDatagramConnectionClosed_ERelayMode_EndToEnd;
  static constexpr ERelayMode ClosedByPeer =
    CMsgSteamDatagramConnectionClosed_ERelayMode_ClosedByPeer;
  static inline bool ERelayMode_IsValid(int value) {
    return CMsgSteamDatagramConnectionClosed_ERelayMode_IsValid(value);
  }
  static constexpr ERelayMode ERelayMode_MIN =
    CMsgSteamDatagramConnectionClosed_ERelayMode_ERelayMode_MIN;
  static constexpr ERelayMode ERelayMode_MAX =
    CMsgSteamDatagramConnectionClosed_ERelayMode_ERelayMode_MAX;
  static constexpr int ERelayMode_ARRAYSIZE =
    CMsgSteamDatagramConnectionClosed_ERelayMode_ERelayMode_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  ERelayMode_descriptor() {
    return CMsgSteamDatagramConnectionClosed_ERelayMode_descriptor();
  }
  template<typename T>
  static inline const std::string& ERelayMode_Name(T enum_t_value) {
    static_assert(::std::is_same<T, ERelayMode>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function ERelayMode_Name.");
    return CMsgSteamDatagramConnectionClosed_ERelayMode_Name(enum_t_value);
  }
  static inline bool ERelayMode_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      ERelayMode* value) {
    return CMsgSteamDatagramConnectionClosed_ERelayMode_Parse(name, value);
  }

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

  enum : int {
    kDebugFieldNumber = 5,
    kForwardTargetRelayRoutingTokenFieldNumber = 11,
    kFromIdentityStringFieldNumber = 15,
    kLegacyFromIdentityBinaryFieldNumber = 13,
    kQualityRelayFieldNumber = 17,
    kQualityE2EFieldNumber = 18,
    kP2PRoutingSummaryFieldNumber = 21,
    kLegacyFromSteamIdFieldNumber = 3,
    kLegacyGameserverRelaySessionIdFieldNumber = 2,
    kRelayModeFieldNumber = 4,
    kReasonCodeFieldNumber = 6,
    kToConnectionIdFieldNumber = 7,
    kFromConnectionIdFieldNumber = 8,
    kToRelaySessionIdFieldNumber = 9,
    kFromRelaySessionIdFieldNumber = 10,
    kForwardTargetRevisionFieldNumber = 12,
    kRoutingSecretFieldNumber = 14,
    kNotPrimarySessionFieldNumber = 16,
    kNotPrimaryTransportFieldNumber = 19,
    kRelayOverrideActiveFieldNumber = 22,
  };
  // 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 bytes forward_target_relay_routing_token = 11;
  bool has_forward_target_relay_routing_token() const;
  private:
  bool _internal_has_forward_target_relay_routing_token() const;
  public:
  void clear_forward_target_relay_routing_token();
  const std::string& forward_target_relay_routing_token() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_forward_target_relay_routing_token(ArgT0&& arg0, ArgT... args);
  std::string* mutable_forward_target_relay_routing_token();
  PROTOBUF_NODISCARD std::string* release_forward_target_relay_routing_token();
  void set_allocated_forward_target_relay_routing_token(std::string* forward_target_relay_routing_token);
  private:
  const std::string& _internal_forward_target_relay_routing_token() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_forward_target_relay_routing_token(const std::string& value);
  std::string* _internal_mutable_forward_target_relay_routing_token();
  public:

  // optional string from_identity_string = 15;
  bool has_from_identity_string() const;
  private:
  bool _internal_has_from_identity_string() const;
  public:
  void clear_from_identity_string();
  const std::string& from_identity_string() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_from_identity_string(ArgT0&& arg0, ArgT... args);
  std::string* mutable_from_identity_string();
  PROTOBUF_NODISCARD std::string* release_from_identity_string();
  void set_allocated_from_identity_string(std::string* from_identity_string);
  private:
  const std::string& _internal_from_identity_string() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_from_identity_string(const std::string& value);
  std::string* _internal_mutable_from_identity_string();
  public:

  // optional .CMsgSteamNetworkingIdentityLegacyBinary legacy_from_identity_binary = 13;
  bool has_legacy_from_identity_binary() const;
  private:
  bool _internal_has_legacy_from_identity_binary() const;
  public:
  void clear_legacy_from_identity_binary();
  const ::CMsgSteamNetworkingIdentityLegacyBinary& legacy_from_identity_binary() const;
  PROTOBUF_NODISCARD ::CMsgSteamNetworkingIdentityLegacyBinary* release_legacy_from_identity_binary();
  ::CMsgSteamNetworkingIdentityLegacyBinary* mutable_legacy_from_identity_binary();
  void set_allocated_legacy_from_identity_binary(::CMsgSteamNetworkingIdentityLegacyBinary* legacy_from_identity_binary);
  private:
  const ::CMsgSteamNetworkingIdentityLegacyBinary& _internal_legacy_from_identity_binary() const;
  ::CMsgSteamNetworkingIdentityLegacyBinary* _internal_mutable_legacy_from_identity_binary();
  public:
  void unsafe_arena_set_allocated_legacy_from_identity_binary(
      ::CMsgSteamNetworkingIdentityLegacyBinary* legacy_from_identity_binary);
  ::CMsgSteamNetworkingIdentityLegacyBinary* unsafe_arena_release_legacy_from_identity_binary();

  // optional .CMsgSteamDatagramConnectionQuality quality_relay = 17;
  bool has_quality_relay() const;
  private:
  bool _internal_has_quality_relay() const;
  public:
  void clear_quality_relay();
  const ::CMsgSteamDatagramConnectionQuality& quality_relay() const;
  PROTOBUF_NODISCARD ::CMsgSteamDatagramConnectionQuality* release_quality_relay();
  ::CMsgSteamDatagramConnectionQuality* mutable_quality_relay();
  void set_allocated_quality_relay(::CMsgSteamDatagramConnectionQuality* quality_relay);
  private:
  const ::CMsgSteamDatagramConnectionQuality& _internal_quality_relay() const;
  ::CMsgSteamDatagramConnectionQuality* _internal_mutable_quality_relay();
  public:
  void unsafe_arena_set_allocated_quality_relay(
      ::CMsgSteamDatagramConnectionQuality* quality_relay);
  ::CMsgSteamDatagramConnectionQuality* unsafe_arena_release_quality_relay();

  // optional .CMsgSteamDatagramConnectionQuality quality_e2e = 18;
  bool has_quality_e2e() const;
  private:
  bool _internal_has_quality_e2e() const;
  public:
  void clear_quality_e2e();
  const ::CMsgSteamDatagramConnectionQuality& quality_e2e() const;
  PROTOBUF_NODISCARD ::CMsgSteamDatagramConnectionQuality* release_quality_e2e();
  ::CMsgSteamDatagramConnectionQuality* mutable_quality_e2e();
  void set_allocated_quality_e2e(::CMsgSteamDatagramConnectionQuality* quality_e2e);
  private:
  const ::CMsgSteamDatagramConnectionQuality& _internal_quality_e2e() const;
  ::CMsgSteamDatagramConnectionQuality* _internal_mutable_quality_e2e();
  public:
  void unsafe_arena_set_allocated_quality_e2e(
      ::CMsgSteamDatagramConnectionQuality* quality_e2e);
  ::CMsgSteamDatagramConnectionQuality* unsafe_arena_release_quality_e2e();

  // optional .CMsgSteamDatagramP2PRoutingSummary p2p_routing_summary = 21;
  bool has_p2p_routing_summary() const;
  private:
  bool _internal_has_p2p_routing_summary() const;
  public:
  void clear_p2p_routing_summary();
  const ::CMsgSteamDatagramP2PRoutingSummary& p2p_routing_summary() const;
  PROTOBUF_NODISCARD ::CMsgSteamDatagramP2PRoutingSummary* release_p2p_routing_summary();
  ::CMsgSteamDatagramP2PRoutingSummary* mutable_p2p_routing_summary();
  void set_allocated_p2p_routing_summary(::CMsgSteamDatagramP2PRoutingSummary* p2p_routing_summary);
  private:
  const ::CMsgSteamDatagramP2PRoutingSummary& _internal_p2p_routing_summary() const;
  ::CMsgSteamDatagramP2PRoutingSummary* _internal_mutable_p2p_routing_summary();
  public:
  void unsafe_arena_set_allocated_p2p_routing_summary(
      ::CMsgSteamDatagramP2PRoutingSummary* p2p_routing_summary);
  ::CMsgSteamDatagramP2PRoutingSummary* unsafe_arena_release_p2p_routing_summary();

  // optional fixed64 legacy_from_steam_id = 3;
  bool has_legacy_from_steam_id() const;
  private:
  bool _internal_has_legacy_from_steam_id() const;
  public:
  void clear_legacy_from_steam_id();
  uint64_t legacy_from_steam_id() const;
  void set_legacy_from_steam_id(uint64_t value);
  private:
  uint64_t _internal_legacy_from_steam_id() const;
  void _internal_set_legacy_from_steam_id(uint64_t value);
  public:

  // optional uint32 legacy_gameserver_relay_session_id = 2;
  bool has_legacy_gameserver_relay_session_id() const;
  private:
  bool _internal_has_legacy_gameserver_relay_session_id() const;
  public:
  void clear_legacy_gameserver_relay_session_id();
  uint32_t legacy_gameserver_relay_session_id() const;
  void set_legacy_gameserver_relay_session_id(uint32_t value);
  private:
  uint32_t _internal_legacy_gameserver_relay_session_id() const;
  void _internal_set_legacy_gameserver_relay_session_id(uint32_t value);
  public:

  // optional .CMsgSteamDatagramConnectionClosed.ERelayMode relay_mode = 4 [default = None];
  bool has_relay_mode() const;
  private:
  bool _internal_has_relay_mode() const;
  public:
  void clear_relay_mode();
  ::CMsgSteamDatagramConnectionClosed_ERelayMode relay_mode() const;
  void set_relay_mode(::CMsgSteamDatagramConnectionClosed_ERelayMode value);
  private:
  ::CMsgSteamDatagramConnectionClosed_ERelayMode _internal_relay_mode() const;
  void _internal_set_relay_mode(::CMsgSteamDatagramConnectionClosed_ERelayMode value);
  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:

  // optional fixed32 to_connection_id = 7;
  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 fixed32 from_connection_id = 8;
  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 fixed32 to_relay_session_id = 9;
  bool has_to_relay_session_id() const;
  private:
  bool _internal_has_to_relay_session_id() const;
  public:
  void clear_to_relay_session_id();
  uint32_t to_relay_session_id() const;
  void set_to_relay_session_id(uint32_t value);
  private:
  uint32_t _internal_to_relay_session_id() const;
  void _internal_set_to_relay_session_id(uint32_t value);
  public:

  // optional fixed32 from_relay_session_id = 10;
  bool has_from_relay_session_id() const;
  private:
  bool _internal_has_from_relay_session_id() const;
  public:
  void clear_from_relay_session_id();
  uint32_t from_relay_session_id() const;
  void set_from_relay_session_id(uint32_t value);
  private:
  uint32_t _internal_from_relay_session_id() const;
  void _internal_set_from_relay_session_id(uint32_t value);
  public:

  // optional uint32 forward_target_revision = 12;
  bool has_forward_target_revision() const;
  private:
  bool _internal_has_forward_target_revision() const;
  public:
  void clear_forward_target_revision();
  uint32_t forward_target_revision() const;
  void set_forward_target_revision(uint32_t value);
  private:
  uint32_t _internal_forward_target_revision() const;
  void _internal_set_forward_target_revision(uint32_t value);
  public:

  // optional fixed64 routing_secret = 14;
  bool has_routing_secret() const;
  private:
  bool _internal_has_routing_secret() const;
  public:
  void clear_routing_secret();
  uint64_t routing_secret() const;
  void set_routing_secret(uint64_t value);
  private:
  uint64_t _internal_routing_secret() const;
  void _internal_set_routing_secret(uint64_t value);
  public:

  // optional bool not_primary_session = 16;
  bool has_not_primary_session() const;
  private:
  bool _internal_has_not_primary_session() const;
  public:
  void clear_not_primary_session();
  bool not_primary_session() const;
  void set_not_primary_session(bool value);
  private:
  bool _internal_not_primary_session() const;
  void _internal_set_not_primary_session(bool value);
  public:

  // optional bool not_primary_transport = 19;
  bool has_not_primary_transport() const;
  private:
  bool _internal_has_not_primary_transport() const;
  public:
  void clear_not_primary_transport();
  bool not_primary_transport() const;
  void set_not_primary_transport(bool value);
  private:
  bool _internal_not_primary_transport() const;
  void _internal_set_not_primary_transport(bool value);
  public:

  // optional bool relay_override_active = 22;
  bool has_relay_override_active() const;
  private:
  bool _internal_has_relay_override_active() const;
  public:
  void clear_relay_override_active();
  bool relay_override_active() const;
  void set_relay_override_active(bool value);
  private:
  bool _internal_relay_override_active() const;
  void _internal_set_relay_override_active(bool value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgSteamDatagramConnectionClosed)
 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_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr forward_target_relay_routing_token_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr from_identity_string_;
    ::CMsgSteamNetworkingIdentityLegacyBinary* legacy_from_identity_binary_;
    ::CMsgSteamDatagramConnectionQuality* quality_relay_;
    ::CMsgSteamDatagramConnectionQuality* quality_e2e_;
    ::CMsgSteamDatagramP2PRoutingSummary* p2p_routing_summary_;
    uint64_t legacy_from_steam_id_;
    uint32_t legacy_gameserver_relay_session_id_;
    int relay_mode_;
    uint32_t reason_code_;
    uint32_t to_connection_id_;
    uint32_t from_connection_id_;
    uint32_t to_relay_session_id_;
    uint32_t from_relay_session_id_;
    uint32_t forward_target_revision_;
    uint64_t routing_secret_;
    bool not_primary_session_;
    bool not_primary_transport_;
    bool relay_override_active_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_steamdatagram_5fmessages_5fsdr_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CMsgSteamDatagramNoConnection& operator=(const CMsgSteamDatagramNoConnection& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgSteamDatagramNoConnection& operator=(CMsgSteamDatagramNoConnection&& 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 CMsgSteamDatagramNoConnection& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgSteamDatagramNoConnection* internal_default_instance() {
    return reinterpret_cast<const CMsgSteamDatagramNoConnection*>(
               &_CMsgSteamDatagramNoConnection_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    23;

  friend void swap(CMsgSteamDatagramNoConnection& a, CMsgSteamDatagramNoConnection& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgSteamDatagramNoConnection* 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(CMsgSteamDatagramNoConnection* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CMsgSteamDatagramNoConnection* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgSteamDatagramNoConnection>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgSteamDatagramNoConnection& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgSteamDatagramNoConnection& from) {
    CMsgSteamDatagramNoConnection::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(CMsgSteamDatagramNoConnection* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgSteamDatagramNoConnection";
  }
  protected:
  explicit CMsgSteamDatagramNoConnection(::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 {
    kFromIdentityStringFieldNumber = 7,
    kQualityRelayFieldNumber = 13,
    kQualityE2EFieldNumber = 14,
    kP2PRoutingSummaryFieldNumber = 16,
    kLegacyFromSteamIdFieldNumber = 3,
    kLegacyGameserverRelaySessionIdFieldNumber = 2,
    kToConnectionIdFieldNumber = 5,
    kFromConnectionIdFieldNumber = 6,
    kToRelaySessionIdFieldNumber = 9,
    kRoutingSecretFieldNumber = 11,
    kFromRelaySessionIdFieldNumber = 10,
    kEndToEndFieldNumber = 4,
    kNotPrimarySessionFieldNumber = 12,
    kNotPrimaryTransportFieldNumber = 15,
    kRelayOverrideActiveFieldNumber = 17,
    kDummyPadFieldNumber = 1023,
  };
  // optional string from_identity_string = 7;
  bool has_from_identity_string() const;
  private:
  bool _internal_has_from_identity_string() const;
  public:
  void clear_from_identity_string();
  const std::string& from_identity_string() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_from_identity_string(ArgT0&& arg0, ArgT... args);
  std::string* mutable_from_identity_string();
  PROTOBUF_NODISCARD std::string* release_from_identity_string();
  void set_allocated_from_identity_string(std::string* from_identity_string);
  private:
  const std::string& _internal_from_identity_string() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_from_identity_string(const std::string& value);
  std::string* _internal_mutable_from_identity_string();
  public:

  // optional .CMsgSteamDatagramConnectionQuality quality_relay = 13;
  bool has_quality_relay() const;
  private:
  bool _internal_has_quality_relay() const;
  public:
  void clear_quality_relay();
  const ::CMsgSteamDatagramConnectionQuality& quality_relay() const;
  PROTOBUF_NODISCARD ::CMsgSteamDatagramConnectionQuality* release_quality_relay();
  ::CMsgSteamDatagramConnectionQuality* mutable_quality_relay();
  void set_allocated_quality_relay(::CMsgSteamDatagramConnectionQuality* quality_relay);
  private:
  const ::CMsgSteamDatagramConnectionQuality& _internal_quality_relay() const;
  ::CMsgSteamDatagramConnectionQuality* _internal_mutable_quality_relay();
  public:
  void unsafe_arena_set_allocated_quality_relay(
      ::CMsgSteamDatagramConnectionQuality* quality_relay);
  ::CMsgSteamDatagramConnectionQuality* unsafe_arena_release_quality_relay();

  // optional .CMsgSteamDatagramConnectionQuality quality_e2e = 14;
  bool has_quality_e2e() const;
  private:
  bool _internal_has_quality_e2e() const;
  public:
  void clear_quality_e2e();
  const ::CMsgSteamDatagramConnectionQuality& quality_e2e() const;
  PROTOBUF_NODISCARD ::CMsgSteamDatagramConnectionQuality* release_quality_e2e();
  ::CMsgSteamDatagramConnectionQuality* mutable_quality_e2e();
  void set_allocated_quality_e2e(::CMsgSteamDatagramConnectionQuality* quality_e2e);
  private:
  const ::CMsgSteamDatagramConnectionQuality& _internal_quality_e2e() const;
  ::CMsgSteamDatagramConnectionQuality* _internal_mutable_quality_e2e();
  public:
  void unsafe_arena_set_allocated_quality_e2e(
      ::CMsgSteamDatagramConnectionQuality* quality_e2e);
  ::CMsgSteamDatagramConnectionQuality* unsafe_arena_release_quality_e2e();

  // optional .CMsgSteamDatagramP2PRoutingSummary p2p_routing_summary = 16;
  bool has_p2p_routing_summary() const;
  private:
  bool _internal_has_p2p_routing_summary() const;
  public:
  void clear_p2p_routing_summary();
  const ::CMsgSteamDatagramP2PRoutingSummary& p2p_routing_summary() const;
  PROTOBUF_NODISCARD ::CMsgSteamDatagramP2PRoutingSummary* release_p2p_routing_summary();
  ::CMsgSteamDatagramP2PRoutingSummary* mutable_p2p_routing_summary();
  void set_allocated_p2p_routing_summary(::CMsgSteamDatagramP2PRoutingSummary* p2p_routing_summary);
  private:
  const ::CMsgSteamDatagramP2PRoutingSummary& _internal_p2p_routing_summary() const;
  ::CMsgSteamDatagramP2PRoutingSummary* _internal_mutable_p2p_routing_summary();
  public:
  void unsafe_arena_set_allocated_p2p_routing_summary(
      ::CMsgSteamDatagramP2PRoutingSummary* p2p_routing_summary);
  ::CMsgSteamDatagramP2PRoutingSummary* unsafe_arena_release_p2p_routing_summary();

  // optional fixed64 legacy_from_steam_id = 3;
  bool has_legacy_from_steam_id() const;
  private:
  bool _internal_has_legacy_from_steam_id() const;
  public:
  void clear_legacy_from_steam_id();
  uint64_t legacy_from_steam_id() const;
  void set_legacy_from_steam_id(uint64_t value);
  private:
  uint64_t _internal_legacy_from_steam_id() const;
  void _internal_set_legacy_from_steam_id(uint64_t value);
  public:

  // optional uint32 legacy_gameserver_relay_session_id = 2;
  bool has_legacy_gameserver_relay_session_id() const;
  private:
  bool _internal_has_legacy_gameserver_relay_session_id() const;
  public:
  void clear_legacy_gameserver_relay_session_id();
  uint32_t legacy_gameserver_relay_session_id() const;
  void set_legacy_gameserver_relay_session_id(uint32_t value);
  private:
  uint32_t _internal_legacy_gameserver_relay_session_id() const;
  void _internal_set_legacy_gameserver_relay_session_id(uint32_t value);
  public:

  // optional fixed32 to_connection_id = 5;
  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 fixed32 from_connection_id = 6;
  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 fixed32 to_relay_session_id = 9;
  bool has_to_relay_session_id() const;
  private:
  bool _internal_has_to_relay_session_id() const;
  public:
  void clear_to_relay_session_id();
  uint32_t to_relay_session_id() const;
  void set_to_relay_session_id(uint32_t value);
  private:
  uint32_t _internal_to_relay_session_id() const;
  void _internal_set_to_relay_session_id(uint32_t value);
  public:

  // optional fixed64 routing_secret = 11;
  bool has_routing_secret() const;
  private:
  bool _internal_has_routing_secret() const;
  public:
  void clear_routing_secret();
  uint64_t routing_secret() const;
  void set_routing_secret(uint64_t value);
  private:
  uint64_t _internal_routing_secret() const;
  void _internal_set_routing_secret(uint64_t value);
  public:

  // optional fixed32 from_relay_session_id = 10;
  bool has_from_relay_session_id() const;
  private:
  bool _internal_has_from_relay_session_id() const;
  public:
  void clear_from_relay_session_id();
  uint32_t from_relay_session_id() const;
  void set_from_relay_session_id(uint32_t value);
  private:
  uint32_t _internal_from_relay_session_id() const;
  void _internal_set_from_relay_session_id(uint32_t value);
  public:

  // optional bool end_to_end = 4;
  bool has_end_to_end() const;
  private:
  bool _internal_has_end_to_end() const;
  public:
  void clear_end_to_end();
  bool end_to_end() const;
  void set_end_to_end(bool value);
  private:
  bool _internal_end_to_end() const;
  void _internal_set_end_to_end(bool value);
  public:

  // optional bool not_primary_session = 12;
  bool has_not_primary_session() const;
  private:
  bool _internal_has_not_primary_session() const;
  public:
  void clear_not_primary_session();
  bool not_primary_session() const;
  void set_not_primary_session(bool value);
  private:
  bool _internal_not_primary_session() const;
  void _internal_set_not_primary_session(bool value);
  public:

  // optional bool not_primary_transport = 15;
  bool has_not_primary_transport() const;
  private:
  bool _internal_has_not_primary_transport() const;
  public:
  void clear_not_primary_transport();
  bool not_primary_transport() const;
  void set_not_primary_transport(bool value);
  private:
  bool _internal_not_primary_transport() const;
  void _internal_set_not_primary_transport(bool value);
  public:

  // optional bool relay_override_active = 17;
  bool has_relay_override_active() const;
  private:
  bool _internal_has_relay_override_active() const;
  public:
  void clear_relay_override_active();
  bool relay_override_active() const;
  void set_relay_override_active(bool value);
  private:
  bool _internal_relay_override_active() const;
  void _internal_set_relay_override_active(bool value);
  public:

  // optional fixed32 dummy_pad = 1023;
  bool has_dummy_pad() const;
  private:
  bool _internal_has_dummy_pad() const;
  public:
  void clear_dummy_pad();
  uint32_t dummy_pad() const;
  void set_dummy_pad(uint32_t value);
  private:
  uint32_t _internal_dummy_pad() const;
  void _internal_set_dummy_pad(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgSteamDatagramNoConnection)
 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_identity_string_;
    ::CMsgSteamDatagramConnectionQuality* quality_relay_;
    ::CMsgSteamDatagramConnectionQuality* quality_e2e_;
    ::CMsgSteamDatagramP2PRoutingSummary* p2p_routing_summary_;
    uint64_t legacy_from_steam_id_;
    uint32_t legacy_gameserver_relay_session_id_;
    uint32_t to_connection_id_;
    uint32_t from_connection_id_;
    uint32_t to_relay_session_id_;
    uint64_t routing_secret_;
    uint32_t from_relay_session_id_;
    bool end_to_end_;
    bool not_primary_session_;
    bool not_primary_transport_;
    bool relay_override_active_;
    uint32_t dummy_pad_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_steamdatagram_5fmessages_5fsdr_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CMsgSteamDatagramGameserverSessionRequest& operator=(const CMsgSteamDatagramGameserverSessionRequest& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgSteamDatagramGameserverSessionRequest& operator=(CMsgSteamDatagramGameserverSessionRequest&& 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 CMsgSteamDatagramGameserverSessionRequest& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgSteamDatagramGameserverSessionRequest* internal_default_instance() {
    return reinterpret_cast<const CMsgSteamDatagramGameserverSessionRequest*>(
               &_CMsgSteamDatagramGameserverSessionRequest_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    24;

  friend void swap(CMsgSteamDatagramGameserverSessionRequest& a, CMsgSteamDatagramGameserverSessionRequest& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgSteamDatagramGameserverSessionRequest* 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(CMsgSteamDatagramGameserverSessionRequest* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CMsgSteamDatagramGameserverSessionRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgSteamDatagramGameserverSessionRequest>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgSteamDatagramGameserverSessionRequest& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgSteamDatagramGameserverSessionRequest& from) {
    CMsgSteamDatagramGameserverSessionRequest::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(CMsgSteamDatagramGameserverSessionRequest* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgSteamDatagramGameserverSessionRequest";
  }
  protected:
  explicit CMsgSteamDatagramGameserverSessionRequest(::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 {
    kTicketFieldNumber = 1,
    kPlatformFieldNumber = 9,
    kBuildFieldNumber = 10,
    kDevGameserverIdentityFieldNumber = 100,
    kDevClientCertFieldNumber = 101,
    kChallengeFieldNumber = 4,
    kChallengeTimeFieldNumber = 3,
    kClientConnectionIdFieldNumber = 5,
    kNetworkConfigVersionFieldNumber = 6,
    kProtocolVersionFieldNumber = 7,
    kServerConnectionIdFieldNumber = 8,
  };
  // optional bytes ticket = 1;
  bool has_ticket() const;
  private:
  bool _internal_has_ticket() const;
  public:
  void clear_ticket();
  const std::string& ticket() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_ticket(ArgT0&& arg0, ArgT... args);
  std::string* mutable_ticket();
  PROTOBUF_NODISCARD std::string* release_ticket();
  void set_allocated_ticket(std::string* ticket);
  private:
  const std::string& _internal_ticket() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_ticket(const std::string& value);
  std::string* _internal_mutable_ticket();
  public:

  // optional string platform = 9;
  bool has_platform() const;
  private:
  bool _internal_has_platform() const;
  public:
  void clear_platform();
  const std::string& platform() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_platform(ArgT0&& arg0, ArgT... args);
  std::string* mutable_platform();
  PROTOBUF_NODISCARD std::string* release_platform();
  void set_allocated_platform(std::string* platform);
  private:
  const std::string& _internal_platform() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_platform(const std::string& value);
  std::string* _internal_mutable_platform();
  public:

  // optional string build = 10;
  bool has_build() const;
  private:
  bool _internal_has_build() const;
  public:
  void clear_build();
  const std::string& build() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_build(ArgT0&& arg0, ArgT... args);
  std::string* mutable_build();
  PROTOBUF_NODISCARD std::string* release_build();
  void set_allocated_build(std::string* build);
  private:
  const std::string& _internal_build() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_build(const std::string& value);
  std::string* _internal_mutable_build();
  public:

  // optional string dev_gameserver_identity = 100;
  bool has_dev_gameserver_identity() const;
  private:
  bool _internal_has_dev_gameserver_identity() const;
  public:
  void clear_dev_gameserver_identity();
  const std::string& dev_gameserver_identity() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_dev_gameserver_identity(ArgT0&& arg0, ArgT... args);
  std::string* mutable_dev_gameserver_identity();
  PROTOBUF_NODISCARD std::string* release_dev_gameserver_identity();
  void set_allocated_dev_gameserver_identity(std::string* dev_gameserver_identity);
  private:
  const std::string& _internal_dev_gameserver_identity() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_dev_gameserver_identity(const std::string& value);
  std::string* _internal_mutable_dev_gameserver_identity();
  public:

  // optional .CMsgSteamDatagramCertificateSigned dev_client_cert = 101;
  bool has_dev_client_cert() const;
  private:
  bool _internal_has_dev_client_cert() const;
  public:
  void clear_dev_client_cert();
  const ::CMsgSteamDatagramCertificateSigned& dev_client_cert() const;
  PROTOBUF_NODISCARD ::CMsgSteamDatagramCertificateSigned* release_dev_client_cert();
  ::CMsgSteamDatagramCertificateSigned* mutable_dev_client_cert();
  void set_allocated_dev_client_cert(::CMsgSteamDatagramCertificateSigned* dev_client_cert);
  private:
  const ::CMsgSteamDatagramCertificateSigned& _internal_dev_client_cert() const;
  ::CMsgSteamDatagramCertificateSigned* _internal_mutable_dev_client_cert();
  public:
  void unsafe_arena_set_allocated_dev_client_cert(
      ::CMsgSteamDatagramCertificateSigned* dev_client_cert);
  ::CMsgSteamDatagramCertificateSigned* unsafe_arena_release_dev_client_cert();

  // optional fixed64 challenge = 4;
  bool has_challenge() const;
  private:
  bool _internal_has_challenge() const;
  public:
  void clear_challenge();
  uint64_t challenge() const;
  void set_challenge(uint64_t value);
  private:
  uint64_t _internal_challenge() const;
  void _internal_set_challenge(uint64_t value);
  public:

  // optional fixed32 challenge_time = 3;
  bool has_challenge_time() const;
  private:
  bool _internal_has_challenge_time() const;
  public:
  void clear_challenge_time();
  uint32_t challenge_time() const;
  void set_challenge_time(uint32_t value);
  private:
  uint32_t _internal_challenge_time() const;
  void _internal_set_challenge_time(uint32_t value);
  public:

  // optional fixed32 client_connection_id = 5;
  bool has_client_connection_id() const;
  private:
  bool _internal_has_client_connection_id() const;
  public:
  void clear_client_connection_id();
  uint32_t client_connection_id() const;
  void set_client_connection_id(uint32_t value);
  private:
  uint32_t _internal_client_connection_id() const;
  void _internal_set_client_connection_id(uint32_t value);
  public:

  // optional uint64 network_config_version = 6;
  bool has_network_config_version() const;
  private:
  bool _internal_has_network_config_version() const;
  public:
  void clear_network_config_version();
  uint64_t network_config_version() const;
  void set_network_config_version(uint64_t value);
  private:
  uint64_t _internal_network_config_version() const;
  void _internal_set_network_config_version(uint64_t value);
  public:

  // optional uint32 protocol_version = 7;
  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 fixed32 server_connection_id = 8;
  bool has_server_connection_id() const;
  private:
  bool _internal_has_server_connection_id() const;
  public:
  void clear_server_connection_id();
  uint32_t server_connection_id() const;
  void set_server_connection_id(uint32_t value);
  private:
  uint32_t _internal_server_connection_id() const;
  void _internal_set_server_connection_id(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgSteamDatagramGameserverSessionRequest)
 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 ticket_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr platform_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr build_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr dev_gameserver_identity_;
    ::CMsgSteamDatagramCertificateSigned* dev_client_cert_;
    uint64_t challenge_;
    uint32_t challenge_time_;
    uint32_t client_connection_id_;
    uint64_t network_config_version_;
    uint32_t protocol_version_;
    uint32_t server_connection_id_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_steamdatagram_5fmessages_5fsdr_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CMsgSteamDatagramGameserverSessionEstablished& operator=(const CMsgSteamDatagramGameserverSessionEstablished& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgSteamDatagramGameserverSessionEstablished& operator=(CMsgSteamDatagramGameserverSessionEstablished&& 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 CMsgSteamDatagramGameserverSessionEstablished& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgSteamDatagramGameserverSessionEstablished* internal_default_instance() {
    return reinterpret_cast<const CMsgSteamDatagramGameserverSessionEstablished*>(
               &_CMsgSteamDatagramGameserverSessionEstablished_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    25;

  friend void swap(CMsgSteamDatagramGameserverSessionEstablished& a, CMsgSteamDatagramGameserverSessionEstablished& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgSteamDatagramGameserverSessionEstablished* 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(CMsgSteamDatagramGameserverSessionEstablished* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CMsgSteamDatagramGameserverSessionEstablished* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgSteamDatagramGameserverSessionEstablished>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgSteamDatagramGameserverSessionEstablished& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgSteamDatagramGameserverSessionEstablished& from) {
    CMsgSteamDatagramGameserverSessionEstablished::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(CMsgSteamDatagramGameserverSessionEstablished* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgSteamDatagramGameserverSessionEstablished";
  }
  protected:
  explicit CMsgSteamDatagramGameserverSessionEstablished(::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 {
    kGameserverIdentityStringFieldNumber = 2,
    kDummyLegacyIdentityBinaryFieldNumber = 7,
    kConnectionIdFieldNumber = 1,
    kSecondsUntilShutdownFieldNumber = 4,
    kLegacyGameserverSteamidFieldNumber = 3,
    kSeqNumR2CFieldNumber = 6,
  };
  // optional string gameserver_identity_string = 2;
  bool has_gameserver_identity_string() const;
  private:
  bool _internal_has_gameserver_identity_string() const;
  public:
  void clear_gameserver_identity_string();
  const std::string& gameserver_identity_string() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_gameserver_identity_string(ArgT0&& arg0, ArgT... args);
  std::string* mutable_gameserver_identity_string();
  PROTOBUF_NODISCARD std::string* release_gameserver_identity_string();
  void set_allocated_gameserver_identity_string(std::string* gameserver_identity_string);
  private:
  const std::string& _internal_gameserver_identity_string() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_gameserver_identity_string(const std::string& value);
  std::string* _internal_mutable_gameserver_identity_string();
  public:

  // optional bytes dummy_legacy_identity_binary = 7;
  bool has_dummy_legacy_identity_binary() const;
  private:
  bool _internal_has_dummy_legacy_identity_binary() const;
  public:
  void clear_dummy_legacy_identity_binary();
  const std::string& dummy_legacy_identity_binary() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_dummy_legacy_identity_binary(ArgT0&& arg0, ArgT... args);
  std::string* mutable_dummy_legacy_identity_binary();
  PROTOBUF_NODISCARD std::string* release_dummy_legacy_identity_binary();
  void set_allocated_dummy_legacy_identity_binary(std::string* dummy_legacy_identity_binary);
  private:
  const std::string& _internal_dummy_legacy_identity_binary() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_dummy_legacy_identity_binary(const std::string& value);
  std::string* _internal_mutable_dummy_legacy_identity_binary();
  public:

  // optional fixed32 connection_id = 1;
  bool has_connection_id() const;
  private:
  bool _internal_has_connection_id() const;
  public:
  void clear_connection_id();
  uint32_t connection_id() const;
  void set_connection_id(uint32_t value);
  private:
  uint32_t _internal_connection_id() const;
  void _internal_set_connection_id(uint32_t value);
  public:

  // optional uint32 seconds_until_shutdown = 4;
  bool has_seconds_until_shutdown() const;
  private:
  bool _internal_has_seconds_until_shutdown() const;
  public:
  void clear_seconds_until_shutdown();
  uint32_t seconds_until_shutdown() const;
  void set_seconds_until_shutdown(uint32_t value);
  private:
  uint32_t _internal_seconds_until_shutdown() const;
  void _internal_set_seconds_until_shutdown(uint32_t value);
  public:

  // optional fixed64 legacy_gameserver_steamid = 3;
  bool has_legacy_gameserver_steamid() const;
  private:
  bool _internal_has_legacy_gameserver_steamid() const;
  public:
  void clear_legacy_gameserver_steamid();
  uint64_t legacy_gameserver_steamid() const;
  void set_legacy_gameserver_steamid(uint64_t value);
  private:
  uint64_t _internal_legacy_gameserver_steamid() const;
  void _internal_set_legacy_gameserver_steamid(uint64_t value);
  public:

  // optional uint32 seq_num_r2c = 6;
  bool has_seq_num_r2c() const;
  private:
  bool _internal_has_seq_num_r2c() const;
  public:
  void clear_seq_num_r2c();
  uint32_t seq_num_r2c() const;
  void set_seq_num_r2c(uint32_t value);
  private:
  uint32_t _internal_seq_num_r2c() const;
  void _internal_set_seq_num_r2c(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgSteamDatagramGameserverSessionEstablished)
 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 gameserver_identity_string_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr dummy_legacy_identity_binary_;
    uint32_t connection_id_;
    uint32_t seconds_until_shutdown_;
    uint64_t legacy_gameserver_steamid_;
    uint32_t seq_num_r2c_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_steamdatagram_5fmessages_5fsdr_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CMsgSteamDatagramConnectionStatsClientToRouter& operator=(const CMsgSteamDatagramConnectionStatsClientToRouter& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgSteamDatagramConnectionStatsClientToRouter& operator=(CMsgSteamDatagramConnectionStatsClientToRouter&& 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 CMsgSteamDatagramConnectionStatsClientToRouter& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgSteamDatagramConnectionStatsClientToRouter* internal_default_instance() {
    return reinterpret_cast<const CMsgSteamDatagramConnectionStatsClientToRouter*>(
               &_CMsgSteamDatagramConnectionStatsClientToRouter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    26;

  friend void swap(CMsgSteamDatagramConnectionStatsClientToRouter& a, CMsgSteamDatagramConnectionStatsClientToRouter& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgSteamDatagramConnectionStatsClientToRouter* 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(CMsgSteamDatagramConnectionStatsClientToRouter* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CMsgSteamDatagramConnectionStatsClientToRouter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgSteamDatagramConnectionStatsClientToRouter>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgSteamDatagramConnectionStatsClientToRouter& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgSteamDatagramConnectionStatsClientToRouter& from) {
    CMsgSteamDatagramConnectionStatsClientToRouter::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(CMsgSteamDatagramConnectionStatsClientToRouter* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgSteamDatagramConnectionStatsClientToRouter";
  }
  protected:
  explicit CMsgSteamDatagramConnectionStatsClientToRouter(::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 CMsgSteamDatagramConnectionStatsClientToRouter_Flags Flags;
  static constexpr Flags ACK_REQUEST_RELAY =
    CMsgSteamDatagramConnectionStatsClientToRouter_Flags_ACK_REQUEST_RELAY;
  static constexpr Flags ACK_REQUEST_E2E =
    CMsgSteamDatagramConnectionStatsClientToRouter_Flags_ACK_REQUEST_E2E;
  static constexpr Flags ACK_REQUEST_IMMEDIATE =
    CMsgSteamDatagramConnectionStatsClientToRouter_Flags_ACK_REQUEST_IMMEDIATE;
  static constexpr Flags NOT_PRIMARY_SESSION =
    CMsgSteamDatagramConnectionStatsClientToRouter_Flags_NOT_PRIMARY_SESSION;
  static constexpr Flags CLIENT_RELAY_OVERRIDE =
    CMsgSteamDatagramConnectionStatsClientToRouter_Flags_CLIENT_RELAY_OVERRIDE;
  static inline bool Flags_IsValid(int value) {
    return CMsgSteamDatagramConnectionStatsClientToRouter_Flags_IsValid(value);
  }
  static constexpr Flags Flags_MIN =
    CMsgSteamDatagramConnectionStatsClientToRouter_Flags_Flags_MIN;
  static constexpr Flags Flags_MAX =
    CMsgSteamDatagramConnectionStatsClientToRouter_Flags_Flags_MAX;
  static constexpr int Flags_ARRAYSIZE =
    CMsgSteamDatagramConnectionStatsClientToRouter_Flags_Flags_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  Flags_descriptor() {
    return CMsgSteamDatagramConnectionStatsClientToRouter_Flags_descriptor();
  }
  template<typename T>
  static inline const std::string& Flags_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Flags>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Flags_Name.");
    return CMsgSteamDatagramConnectionStatsClientToRouter_Flags_Name(enum_t_value);
  }
  static inline bool Flags_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Flags* value) {
    return CMsgSteamDatagramConnectionStatsClientToRouter_Flags_Parse(name, value);
  }

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

  enum : int {
    kAckRelayFieldNumber = 4,
    kLegacyAckE2EFieldNumber = 5,
    kQualityRelayFieldNumber = 1,
    kQualityE2EFieldNumber = 2,
    kFlagsFieldNumber = 6,
    kClientConnectionIdFieldNumber = 8,
    kSeqNumC2RFieldNumber = 9,
    kSeqNumE2EFieldNumber = 10,
  };
  // repeated fixed32 ack_relay = 4;
  int ack_relay_size() const;
  private:
  int _internal_ack_relay_size() const;
  public:
  void clear_ack_relay();
  private:
  uint32_t _internal_ack_relay(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      _internal_ack_relay() const;
  void _internal_add_ack_relay(uint32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      _internal_mutable_ack_relay();
  public:
  uint32_t ack_relay(int index) const;
  void set_ack_relay(int index, uint32_t value);
  void add_ack_relay(uint32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      ack_relay() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      mutable_ack_relay();

  // repeated fixed32 legacy_ack_e2e = 5;
  int legacy_ack_e2e_size() const;
  private:
  int _internal_legacy_ack_e2e_size() const;
  public:
  void clear_legacy_ack_e2e();
  private:
  uint32_t _internal_legacy_ack_e2e(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      _internal_legacy_ack_e2e() const;
  void _internal_add_legacy_ack_e2e(uint32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      _internal_mutable_legacy_ack_e2e();
  public:
  uint32_t legacy_ack_e2e(int index) const;
  void set_legacy_ack_e2e(int index, uint32_t value);
  void add_legacy_ack_e2e(uint32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      legacy_ack_e2e() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      mutable_legacy_ack_e2e();

  // optional .CMsgSteamDatagramConnectionQuality quality_relay = 1;
  bool has_quality_relay() const;
  private:
  bool _internal_has_quality_relay() const;
  public:
  void clear_quality_relay();
  const ::CMsgSteamDatagramConnectionQuality& quality_relay() const;
  PROTOBUF_NODISCARD ::CMsgSteamDatagramConnectionQuality* release_quality_relay();
  ::CMsgSteamDatagramConnectionQuality* mutable_quality_relay();
  void set_allocated_quality_relay(::CMsgSteamDatagramConnectionQuality* quality_relay);
  private:
  const ::CMsgSteamDatagramConnectionQuality& _internal_quality_relay() const;
  ::CMsgSteamDatagramConnectionQuality* _internal_mutable_quality_relay();
  public:
  void unsafe_arena_set_allocated_quality_relay(
      ::CMsgSteamDatagramConnectionQuality* quality_relay);
  ::CMsgSteamDatagramConnectionQuality* unsafe_arena_release_quality_relay();

  // optional .CMsgSteamDatagramConnectionQuality quality_e2e = 2;
  bool has_quality_e2e() const;
  private:
  bool _internal_has_quality_e2e() const;
  public:
  void clear_quality_e2e();
  const ::CMsgSteamDatagramConnectionQuality& quality_e2e() const;
  PROTOBUF_NODISCARD ::CMsgSteamDatagramConnectionQuality* release_quality_e2e();
  ::CMsgSteamDatagramConnectionQuality* mutable_quality_e2e();
  void set_allocated_quality_e2e(::CMsgSteamDatagramConnectionQuality* quality_e2e);
  private:
  const ::CMsgSteamDatagramConnectionQuality& _internal_quality_e2e() const;
  ::CMsgSteamDatagramConnectionQuality* _internal_mutable_quality_e2e();
  public:
  void unsafe_arena_set_allocated_quality_e2e(
      ::CMsgSteamDatagramConnectionQuality* quality_e2e);
  ::CMsgSteamDatagramConnectionQuality* unsafe_arena_release_quality_e2e();

  // optional uint32 flags = 6;
  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 fixed32 client_connection_id = 8;
  bool has_client_connection_id() const;
  private:
  bool _internal_has_client_connection_id() const;
  public:
  void clear_client_connection_id();
  uint32_t client_connection_id() const;
  void set_client_connection_id(uint32_t value);
  private:
  uint32_t _internal_client_connection_id() const;
  void _internal_set_client_connection_id(uint32_t value);
  public:

  // optional uint32 seq_num_c2r = 9;
  bool has_seq_num_c2r() const;
  private:
  bool _internal_has_seq_num_c2r() const;
  public:
  void clear_seq_num_c2r();
  uint32_t seq_num_c2r() const;
  void set_seq_num_c2r(uint32_t value);
  private:
  uint32_t _internal_seq_num_c2r() const;
  void _internal_set_seq_num_c2r(uint32_t value);
  public:

  // optional uint32 seq_num_e2e = 10;
  bool has_seq_num_e2e() const;
  private:
  bool _internal_has_seq_num_e2e() const;
  public:
  void clear_seq_num_e2e();
  uint32_t seq_num_e2e() const;
  void set_seq_num_e2e(uint32_t value);
  private:
  uint32_t _internal_seq_num_e2e() const;
  void _internal_set_seq_num_e2e(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgSteamDatagramConnectionStatsClientToRouter)
 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< uint32_t > ack_relay_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > legacy_ack_e2e_;
    ::CMsgSteamDatagramConnectionQuality* quality_relay_;
    ::CMsgSteamDatagramConnectionQuality* quality_e2e_;
    uint32_t flags_;
    uint32_t client_connection_id_;
    uint32_t seq_num_c2r_;
    uint32_t seq_num_e2e_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_steamdatagram_5fmessages_5fsdr_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CMsgSteamDatagramConnectionStatsRouterToClient& operator=(const CMsgSteamDatagramConnectionStatsRouterToClient& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgSteamDatagramConnectionStatsRouterToClient& operator=(CMsgSteamDatagramConnectionStatsRouterToClient&& 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 CMsgSteamDatagramConnectionStatsRouterToClient& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgSteamDatagramConnectionStatsRouterToClient* internal_default_instance() {
    return reinterpret_cast<const CMsgSteamDatagramConnectionStatsRouterToClient*>(
               &_CMsgSteamDatagramConnectionStatsRouterToClient_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    27;

  friend void swap(CMsgSteamDatagramConnectionStatsRouterToClient& a, CMsgSteamDatagramConnectionStatsRouterToClient& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgSteamDatagramConnectionStatsRouterToClient* 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(CMsgSteamDatagramConnectionStatsRouterToClient* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CMsgSteamDatagramConnectionStatsRouterToClient* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgSteamDatagramConnectionStatsRouterToClient>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgSteamDatagramConnectionStatsRouterToClient& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgSteamDatagramConnectionStatsRouterToClient& from) {
    CMsgSteamDatagramConnectionStatsRouterToClient::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(CMsgSteamDatagramConnectionStatsRouterToClient* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgSteamDatagramConnectionStatsRouterToClient";
  }
  protected:
  explicit CMsgSteamDatagramConnectionStatsRouterToClient(::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 CMsgSteamDatagramConnectionStatsRouterToClient_Flags Flags;
  static constexpr Flags ACK_REQUEST_RELAY =
    CMsgSteamDatagramConnectionStatsRouterToClient_Flags_ACK_REQUEST_RELAY;
  static constexpr Flags ACK_REQUEST_E2E =
    CMsgSteamDatagramConnectionStatsRouterToClient_Flags_ACK_REQUEST_E2E;
  static constexpr Flags ACK_REQUEST_IMMEDIATE =
    CMsgSteamDatagramConnectionStatsRouterToClient_Flags_ACK_REQUEST_IMMEDIATE;
  static inline bool Flags_IsValid(int value) {
    return CMsgSteamDatagramConnectionStatsRouterToClient_Flags_IsValid(value);
  }
  static constexpr Flags Flags_MIN =
    CMsgSteamDatagramConnectionStatsRouterToClient_Flags_Flags_MIN;
  static constexpr Flags Flags_MAX =
    CMsgSteamDatagramConnectionStatsRouterToClient_Flags_Flags_MAX;
  static constexpr int Flags_ARRAYSIZE =
    CMsgSteamDatagramConnectionStatsRouterToClient_Flags_Flags_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  Flags_descriptor() {
    return CMsgSteamDatagramConnectionStatsRouterToClient_Flags_descriptor();
  }
  template<typename T>
  static inline const std::string& Flags_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Flags>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Flags_Name.");
    return CMsgSteamDatagramConnectionStatsRouterToClient_Flags_Name(enum_t_value);
  }
  static inline bool Flags_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Flags* value) {
    return CMsgSteamDatagramConnectionStatsRouterToClient_Flags_Parse(name, value);
  }

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

  enum : int {
    kAckRelayFieldNumber = 13,
    kLegacyAckE2EFieldNumber = 14,
    kQualityRelayFieldNumber = 1,
    kQualityE2EFieldNumber = 2,
    kSecondsUntilShutdownFieldNumber = 6,
    kClientConnectionIdFieldNumber = 7,
    kSeqNumR2CFieldNumber = 8,
    kSeqNumE2EFieldNumber = 9,
    kMigrateRequestIpFieldNumber = 10,
    kMigrateRequestPortFieldNumber = 11,
    kScoringPenaltyRelayClusterFieldNumber = 12,
    kFlagsFieldNumber = 15,
  };
  // repeated fixed32 ack_relay = 13;
  int ack_relay_size() const;
  private:
  int _internal_ack_relay_size() const;
  public:
  void clear_ack_relay();
  private:
  uint32_t _internal_ack_relay(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      _internal_ack_relay() const;
  void _internal_add_ack_relay(uint32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      _internal_mutable_ack_relay();
  public:
  uint32_t ack_relay(int index) const;
  void set_ack_relay(int index, uint32_t value);
  void add_ack_relay(uint32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      ack_relay() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      mutable_ack_relay();

  // repeated fixed32 legacy_ack_e2e = 14;
  int legacy_ack_e2e_size() const;
  private:
  int _internal_legacy_ack_e2e_size() const;
  public:
  void clear_legacy_ack_e2e();
  private:
  uint32_t _internal_legacy_ack_e2e(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      _internal_legacy_ack_e2e() const;
  void _internal_add_legacy_ack_e2e(uint32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      _internal_mutable_legacy_ack_e2e();
  public:
  uint32_t legacy_ack_e2e(int index) const;
  void set_legacy_ack_e2e(int index, uint32_t value);
  void add_legacy_ack_e2e(uint32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      legacy_ack_e2e() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      mutable_legacy_ack_e2e();

  // optional .CMsgSteamDatagramConnectionQuality quality_relay = 1;
  bool has_quality_relay() const;
  private:
  bool _internal_has_quality_relay() const;
  public:
  void clear_quality_relay();
  const ::CMsgSteamDatagramConnectionQuality& quality_relay() const;
  PROTOBUF_NODISCARD ::CMsgSteamDatagramConnectionQuality* release_quality_relay();
  ::CMsgSteamDatagramConnectionQuality* mutable_quality_relay();
  void set_allocated_quality_relay(::CMsgSteamDatagramConnectionQuality* quality_relay);
  private:
  const ::CMsgSteamDatagramConnectionQuality& _internal_quality_relay() const;
  ::CMsgSteamDatagramConnectionQuality* _internal_mutable_quality_relay();
  public:
  void unsafe_arena_set_allocated_quality_relay(
      ::CMsgSteamDatagramConnectionQuality* quality_relay);
  ::CMsgSteamDatagramConnectionQuality* unsafe_arena_release_quality_relay();

  // optional .CMsgSteamDatagramConnectionQuality quality_e2e = 2;
  bool has_quality_e2e() const;
  private:
  bool _internal_has_quality_e2e() const;
  public:
  void clear_quality_e2e();
  const ::CMsgSteamDatagramConnectionQuality& quality_e2e() const;
  PROTOBUF_NODISCARD ::CMsgSteamDatagramConnectionQuality* release_quality_e2e();
  ::CMsgSteamDatagramConnectionQuality* mutable_quality_e2e();
  void set_allocated_quality_e2e(::CMsgSteamDatagramConnectionQuality* quality_e2e);
  private:
  const ::CMsgSteamDatagramConnectionQuality& _internal_quality_e2e() const;
  ::CMsgSteamDatagramConnectionQuality* _internal_mutable_quality_e2e();
  public:
  void unsafe_arena_set_allocated_quality_e2e(
      ::CMsgSteamDatagramConnectionQuality* quality_e2e);
  ::CMsgSteamDatagramConnectionQuality* unsafe_arena_release_quality_e2e();

  // optional uint32 seconds_until_shutdown = 6;
  bool has_seconds_until_shutdown() const;
  private:
  bool _internal_has_seconds_until_shutdown() const;
  public:
  void clear_seconds_until_shutdown();
  uint32_t seconds_until_shutdown() const;
  void set_seconds_until_shutdown(uint32_t value);
  private:
  uint32_t _internal_seconds_until_shutdown() const;
  void _internal_set_seconds_until_shutdown(uint32_t value);
  public:

  // optional fixed32 client_connection_id = 7;
  bool has_client_connection_id() const;
  private:
  bool _internal_has_client_connection_id() const;
  public:
  void clear_client_connection_id();
  uint32_t client_connection_id() const;
  void set_client_connection_id(uint32_t value);
  private:
  uint32_t _internal_client_connection_id() const;
  void _internal_set_client_connection_id(uint32_t value);
  public:

  // optional uint32 seq_num_r2c = 8;
  bool has_seq_num_r2c() const;
  private:
  bool _internal_has_seq_num_r2c() const;
  public:
  void clear_seq_num_r2c();
  uint32_t seq_num_r2c() const;
  void set_seq_num_r2c(uint32_t value);
  private:
  uint32_t _internal_seq_num_r2c() const;
  void _internal_set_seq_num_r2c(uint32_t value);
  public:

  // optional uint32 seq_num_e2e = 9;
  bool has_seq_num_e2e() const;
  private:
  bool _internal_has_seq_num_e2e() const;
  public:
  void clear_seq_num_e2e();
  uint32_t seq_num_e2e() const;
  void set_seq_num_e2e(uint32_t value);
  private:
  uint32_t _internal_seq_num_e2e() const;
  void _internal_set_seq_num_e2e(uint32_t value);
  public:

  // optional fixed32 migrate_request_ip = 10;
  bool has_migrate_request_ip() const;
  private:
  bool _internal_has_migrate_request_ip() const;
  public:
  void clear_migrate_request_ip();
  uint32_t migrate_request_ip() const;
  void set_migrate_request_ip(uint32_t value);
  private:
  uint32_t _internal_migrate_request_ip() const;
  void _internal_set_migrate_request_ip(uint32_t value);
  public:

  // optional uint32 migrate_request_port = 11;
  bool has_migrate_request_port() const;
  private:
  bool _internal_has_migrate_request_port() const;
  public:
  void clear_migrate_request_port();
  uint32_t migrate_request_port() const;
  void set_migrate_request_port(uint32_t value);
  private:
  uint32_t _internal_migrate_request_port() const;
  void _internal_set_migrate_request_port(uint32_t value);
  public:

  // optional uint32 scoring_penalty_relay_cluster = 12;
  bool has_scoring_penalty_relay_cluster() const;
  private:
  bool _internal_has_scoring_penalty_relay_cluster() const;
  public:
  void clear_scoring_penalty_relay_cluster();
  uint32_t scoring_penalty_relay_cluster() const;
  void set_scoring_penalty_relay_cluster(uint32_t value);
  private:
  uint32_t _internal_scoring_penalty_relay_cluster() const;
  void _internal_set_scoring_penalty_relay_cluster(uint32_t value);
  public:

  // optional uint32 flags = 15;
  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:

  // @@protoc_insertion_point(class_scope:CMsgSteamDatagramConnectionStatsRouterToClient)
 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< uint32_t > ack_relay_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > legacy_ack_e2e_;
    ::CMsgSteamDatagramConnectionQuality* quality_relay_;
    ::CMsgSteamDatagramConnectionQuality* quality_e2e_;
    uint32_t seconds_until_shutdown_;
    uint32_t client_connection_id_;
    uint32_t seq_num_r2c_;
    uint32_t seq_num_e2e_;
    uint32_t migrate_request_ip_;
    uint32_t migrate_request_port_;
    uint32_t scoring_penalty_relay_cluster_;
    uint32_t flags_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_steamdatagram_5fmessages_5fsdr_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CMsgSteamDatagramConnectionStatsRouterToServer& operator=(const CMsgSteamDatagramConnectionStatsRouterToServer& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgSteamDatagramConnectionStatsRouterToServer& operator=(CMsgSteamDatagramConnectionStatsRouterToServer&& 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 CMsgSteamDatagramConnectionStatsRouterToServer& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgSteamDatagramConnectionStatsRouterToServer* internal_default_instance() {
    return reinterpret_cast<const CMsgSteamDatagramConnectionStatsRouterToServer*>(
               &_CMsgSteamDatagramConnectionStatsRouterToServer_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    28;

  friend void swap(CMsgSteamDatagramConnectionStatsRouterToServer& a, CMsgSteamDatagramConnectionStatsRouterToServer& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgSteamDatagramConnectionStatsRouterToServer* 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(CMsgSteamDatagramConnectionStatsRouterToServer* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CMsgSteamDatagramConnectionStatsRouterToServer* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgSteamDatagramConnectionStatsRouterToServer>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgSteamDatagramConnectionStatsRouterToServer& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgSteamDatagramConnectionStatsRouterToServer& from) {
    CMsgSteamDatagramConnectionStatsRouterToServer::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(CMsgSteamDatagramConnectionStatsRouterToServer* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgSteamDatagramConnectionStatsRouterToServer";
  }
  protected:
  explicit CMsgSteamDatagramConnectionStatsRouterToServer(::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 CMsgSteamDatagramConnectionStatsRouterToServer_Flags Flags;
  static constexpr Flags ACK_REQUEST_RELAY =
    CMsgSteamDatagramConnectionStatsRouterToServer_Flags_ACK_REQUEST_RELAY;
  static constexpr Flags ACK_REQUEST_E2E =
    CMsgSteamDatagramConnectionStatsRouterToServer_Flags_ACK_REQUEST_E2E;
  static constexpr Flags ACK_REQUEST_IMMEDIATE =
    CMsgSteamDatagramConnectionStatsRouterToServer_Flags_ACK_REQUEST_IMMEDIATE;
  static inline bool Flags_IsValid(int value) {
    return CMsgSteamDatagramConnectionStatsRouterToServer_Flags_IsValid(value);
  }
  static constexpr Flags Flags_MIN =
    CMsgSteamDatagramConnectionStatsRouterToServer_Flags_Flags_MIN;
  static constexpr Flags Flags_MAX =
    CMsgSteamDatagramConnectionStatsRouterToServer_Flags_Flags_MAX;
  static constexpr int Flags_ARRAYSIZE =
    CMsgSteamDatagramConnectionStatsRouterToServer_Flags_Flags_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  Flags_descriptor() {
    return CMsgSteamDatagramConnectionStatsRouterToServer_Flags_descriptor();
  }
  template<typename T>
  static inline const std::string& Flags_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Flags>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Flags_Name.");
    return CMsgSteamDatagramConnectionStatsRouterToServer_Flags_Name(enum_t_value);
  }
  static inline bool Flags_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Flags* value) {
    return CMsgSteamDatagramConnectionStatsRouterToServer_Flags_Parse(name, value);
  }

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

  enum : int {
    kAckRelayFieldNumber = 10,
    kLegacyAckE2EFieldNumber = 11,
    kClientIdentityStringFieldNumber = 15,
    kQualityRelayFieldNumber = 1,
    kQualityE2EFieldNumber = 2,
    kSeqNumR2SFieldNumber = 5,
    kSeqNumE2EFieldNumber = 6,
    kLegacyClientSteamIdFieldNumber = 7,
    kRelaySessionIdFieldNumber = 8,
    kClientConnectionIdFieldNumber = 9,
    kFlagsFieldNumber = 12,
    kServerConnectionIdFieldNumber = 13,
    kRoutingSecretFieldNumber = 14,
  };
  // repeated fixed32 ack_relay = 10;
  int ack_relay_size() const;
  private:
  int _internal_ack_relay_size() const;
  public:
  void clear_ack_relay();
  private:
  uint32_t _internal_ack_relay(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      _internal_ack_relay() const;
  void _internal_add_ack_relay(uint32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      _internal_mutable_ack_relay();
  public:
  uint32_t ack_relay(int index) const;
  void set_ack_relay(int index, uint32_t value);
  void add_ack_relay(uint32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      ack_relay() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      mutable_ack_relay();

  // repeated fixed32 legacy_ack_e2e = 11;
  int legacy_ack_e2e_size() const;
  private:
  int _internal_legacy_ack_e2e_size() const;
  public:
  void clear_legacy_ack_e2e();
  private:
  uint32_t _internal_legacy_ack_e2e(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      _internal_legacy_ack_e2e() const;
  void _internal_add_legacy_ack_e2e(uint32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      _internal_mutable_legacy_ack_e2e();
  public:
  uint32_t legacy_ack_e2e(int index) const;
  void set_legacy_ack_e2e(int index, uint32_t value);
  void add_legacy_ack_e2e(uint32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      legacy_ack_e2e() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      mutable_legacy_ack_e2e();

  // optional string client_identity_string = 15;
  bool has_client_identity_string() const;
  private:
  bool _internal_has_client_identity_string() const;
  public:
  void clear_client_identity_string();
  const std::string& client_identity_string() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_client_identity_string(ArgT0&& arg0, ArgT... args);
  std::string* mutable_client_identity_string();
  PROTOBUF_NODISCARD std::string* release_client_identity_string();
  void set_allocated_client_identity_string(std::string* client_identity_string);
  private:
  const std::string& _internal_client_identity_string() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_client_identity_string(const std::string& value);
  std::string* _internal_mutable_client_identity_string();
  public:

  // optional .CMsgSteamDatagramConnectionQuality quality_relay = 1;
  bool has_quality_relay() const;
  private:
  bool _internal_has_quality_relay() const;
  public:
  void clear_quality_relay();
  const ::CMsgSteamDatagramConnectionQuality& quality_relay() const;
  PROTOBUF_NODISCARD ::CMsgSteamDatagramConnectionQuality* release_quality_relay();
  ::CMsgSteamDatagramConnectionQuality* mutable_quality_relay();
  void set_allocated_quality_relay(::CMsgSteamDatagramConnectionQuality* quality_relay);
  private:
  const ::CMsgSteamDatagramConnectionQuality& _internal_quality_relay() const;
  ::CMsgSteamDatagramConnectionQuality* _internal_mutable_quality_relay();
  public:
  void unsafe_arena_set_allocated_quality_relay(
      ::CMsgSteamDatagramConnectionQuality* quality_relay);
  ::CMsgSteamDatagramConnectionQuality* unsafe_arena_release_quality_relay();

  // optional .CMsgSteamDatagramConnectionQuality quality_e2e = 2;
  bool has_quality_e2e() const;
  private:
  bool _internal_has_quality_e2e() const;
  public:
  void clear_quality_e2e();
  const ::CMsgSteamDatagramConnectionQuality& quality_e2e() const;
  PROTOBUF_NODISCARD ::CMsgSteamDatagramConnectionQuality* release_quality_e2e();
  ::CMsgSteamDatagramConnectionQuality* mutable_quality_e2e();
  void set_allocated_quality_e2e(::CMsgSteamDatagramConnectionQuality* quality_e2e);
  private:
  const ::CMsgSteamDatagramConnectionQuality& _internal_quality_e2e() const;
  ::CMsgSteamDatagramConnectionQuality* _internal_mutable_quality_e2e();
  public:
  void unsafe_arena_set_allocated_quality_e2e(
      ::CMsgSteamDatagramConnectionQuality* quality_e2e);
  ::CMsgSteamDatagramConnectionQuality* unsafe_arena_release_quality_e2e();

  // optional uint32 seq_num_r2s = 5;
  bool has_seq_num_r2s() const;
  private:
  bool _internal_has_seq_num_r2s() const;
  public:
  void clear_seq_num_r2s();
  uint32_t seq_num_r2s() const;
  void set_seq_num_r2s(uint32_t value);
  private:
  uint32_t _internal_seq_num_r2s() const;
  void _internal_set_seq_num_r2s(uint32_t value);
  public:

  // optional uint32 seq_num_e2e = 6;
  bool has_seq_num_e2e() const;
  private:
  bool _internal_has_seq_num_e2e() const;
  public:
  void clear_seq_num_e2e();
  uint32_t seq_num_e2e() const;
  void set_seq_num_e2e(uint32_t value);
  private:
  uint32_t _internal_seq_num_e2e() const;
  void _internal_set_seq_num_e2e(uint32_t value);
  public:

  // optional fixed64 legacy_client_steam_id = 7;
  bool has_legacy_client_steam_id() const;
  private:
  bool _internal_has_legacy_client_steam_id() const;
  public:
  void clear_legacy_client_steam_id();
  uint64_t legacy_client_steam_id() const;
  void set_legacy_client_steam_id(uint64_t value);
  private:
  uint64_t _internal_legacy_client_steam_id() const;
  void _internal_set_legacy_client_steam_id(uint64_t value);
  public:

  // optional uint32 relay_session_id = 8;
  bool has_relay_session_id() const;
  private:
  bool _internal_has_relay_session_id() const;
  public:
  void clear_relay_session_id();
  uint32_t relay_session_id() const;
  void set_relay_session_id(uint32_t value);
  private:
  uint32_t _internal_relay_session_id() const;
  void _internal_set_relay_session_id(uint32_t value);
  public:

  // optional fixed32 client_connection_id = 9;
  bool has_client_connection_id() const;
  private:
  bool _internal_has_client_connection_id() const;
  public:
  void clear_client_connection_id();
  uint32_t client_connection_id() const;
  void set_client_connection_id(uint32_t value);
  private:
  uint32_t _internal_client_connection_id() const;
  void _internal_set_client_connection_id(uint32_t value);
  public:

  // optional uint32 flags = 12;
  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 fixed32 server_connection_id = 13;
  bool has_server_connection_id() const;
  private:
  bool _internal_has_server_connection_id() const;
  public:
  void clear_server_connection_id();
  uint32_t server_connection_id() const;
  void set_server_connection_id(uint32_t value);
  private:
  uint32_t _internal_server_connection_id() const;
  void _internal_set_server_connection_id(uint32_t value);
  public:

  // optional fixed64 routing_secret = 14;
  bool has_routing_secret() const;
  private:
  bool _internal_has_routing_secret() const;
  public:
  void clear_routing_secret();
  uint64_t routing_secret() const;
  void set_routing_secret(uint64_t value);
  private:
  uint64_t _internal_routing_secret() const;
  void _internal_set_routing_secret(uint64_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgSteamDatagramConnectionStatsRouterToServer)
 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< uint32_t > ack_relay_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > legacy_ack_e2e_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr client_identity_string_;
    ::CMsgSteamDatagramConnectionQuality* quality_relay_;
    ::CMsgSteamDatagramConnectionQuality* quality_e2e_;
    uint32_t seq_num_r2s_;
    uint32_t seq_num_e2e_;
    uint64_t legacy_client_steam_id_;
    uint32_t relay_session_id_;
    uint32_t client_connection_id_;
    uint32_t flags_;
    uint32_t server_connection_id_;
    uint64_t routing_secret_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_steamdatagram_5fmessages_5fsdr_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CMsgSteamDatagramConnectionStatsServerToRouter& operator=(const CMsgSteamDatagramConnectionStatsServerToRouter& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgSteamDatagramConnectionStatsServerToRouter& operator=(CMsgSteamDatagramConnectionStatsServerToRouter&& 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 CMsgSteamDatagramConnectionStatsServerToRouter& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgSteamDatagramConnectionStatsServerToRouter* internal_default_instance() {
    return reinterpret_cast<const CMsgSteamDatagramConnectionStatsServerToRouter*>(
               &_CMsgSteamDatagramConnectionStatsServerToRouter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    29;

  friend void swap(CMsgSteamDatagramConnectionStatsServerToRouter& a, CMsgSteamDatagramConnectionStatsServerToRouter& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgSteamDatagramConnectionStatsServerToRouter* 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(CMsgSteamDatagramConnectionStatsServerToRouter* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CMsgSteamDatagramConnectionStatsServerToRouter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgSteamDatagramConnectionStatsServerToRouter>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgSteamDatagramConnectionStatsServerToRouter& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgSteamDatagramConnectionStatsServerToRouter& from) {
    CMsgSteamDatagramConnectionStatsServerToRouter::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(CMsgSteamDatagramConnectionStatsServerToRouter* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgSteamDatagramConnectionStatsServerToRouter";
  }
  protected:
  explicit CMsgSteamDatagramConnectionStatsServerToRouter(::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 CMsgSteamDatagramConnectionStatsServerToRouter_Flags Flags;
  static constexpr Flags ACK_REQUEST_RELAY =
    CMsgSteamDatagramConnectionStatsServerToRouter_Flags_ACK_REQUEST_RELAY;
  static constexpr Flags ACK_REQUEST_E2E =
    CMsgSteamDatagramConnectionStatsServerToRouter_Flags_ACK_REQUEST_E2E;
  static constexpr Flags ACK_REQUEST_IMMEDIATE =
    CMsgSteamDatagramConnectionStatsServerToRouter_Flags_ACK_REQUEST_IMMEDIATE;
  static inline bool Flags_IsValid(int value) {
    return CMsgSteamDatagramConnectionStatsServerToRouter_Flags_IsValid(value);
  }
  static constexpr Flags Flags_MIN =
    CMsgSteamDatagramConnectionStatsServerToRouter_Flags_Flags_MIN;
  static constexpr Flags Flags_MAX =
    CMsgSteamDatagramConnectionStatsServerToRouter_Flags_Flags_MAX;
  static constexpr int Flags_ARRAYSIZE =
    CMsgSteamDatagramConnectionStatsServerToRouter_Flags_Flags_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  Flags_descriptor() {
    return CMsgSteamDatagramConnectionStatsServerToRouter_Flags_descriptor();
  }
  template<typename T>
  static inline const std::string& Flags_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Flags>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Flags_Name.");
    return CMsgSteamDatagramConnectionStatsServerToRouter_Flags_Name(enum_t_value);
  }
  static inline bool Flags_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Flags* value) {
    return CMsgSteamDatagramConnectionStatsServerToRouter_Flags_Parse(name, value);
  }

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

  enum : int {
    kAckRelayFieldNumber = 8,
    kLegacyAckE2EFieldNumber = 9,
    kQualityRelayFieldNumber = 1,
    kQualityE2EFieldNumber = 2,
    kSeqNumS2RFieldNumber = 3,
    kSeqNumE2EFieldNumber = 4,
    kRelaySessionIdFieldNumber = 6,
    kClientConnectionIdFieldNumber = 7,
    kFlagsFieldNumber = 10,
    kServerConnectionIdFieldNumber = 11,
  };
  // repeated fixed32 ack_relay = 8;
  int ack_relay_size() const;
  private:
  int _internal_ack_relay_size() const;
  public:
  void clear_ack_relay();
  private:
  uint32_t _internal_ack_relay(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      _internal_ack_relay() const;
  void _internal_add_ack_relay(uint32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      _internal_mutable_ack_relay();
  public:
  uint32_t ack_relay(int index) const;
  void set_ack_relay(int index, uint32_t value);
  void add_ack_relay(uint32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      ack_relay() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      mutable_ack_relay();

  // repeated fixed32 legacy_ack_e2e = 9;
  int legacy_ack_e2e_size() const;
  private:
  int _internal_legacy_ack_e2e_size() const;
  public:
  void clear_legacy_ack_e2e();
  private:
  uint32_t _internal_legacy_ack_e2e(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      _internal_legacy_ack_e2e() const;
  void _internal_add_legacy_ack_e2e(uint32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      _internal_mutable_legacy_ack_e2e();
  public:
  uint32_t legacy_ack_e2e(int index) const;
  void set_legacy_ack_e2e(int index, uint32_t value);
  void add_legacy_ack_e2e(uint32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      legacy_ack_e2e() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      mutable_legacy_ack_e2e();

  // optional .CMsgSteamDatagramConnectionQuality quality_relay = 1;
  bool has_quality_relay() const;
  private:
  bool _internal_has_quality_relay() const;
  public:
  void clear_quality_relay();
  const ::CMsgSteamDatagramConnectionQuality& quality_relay() const;
  PROTOBUF_NODISCARD ::CMsgSteamDatagramConnectionQuality* release_quality_relay();
  ::CMsgSteamDatagramConnectionQuality* mutable_quality_relay();
  void set_allocated_quality_relay(::CMsgSteamDatagramConnectionQuality* quality_relay);
  private:
  const ::CMsgSteamDatagramConnectionQuality& _internal_quality_relay() const;
  ::CMsgSteamDatagramConnectionQuality* _internal_mutable_quality_relay();
  public:
  void unsafe_arena_set_allocated_quality_relay(
      ::CMsgSteamDatagramConnectionQuality* quality_relay);
  ::CMsgSteamDatagramConnectionQuality* unsafe_arena_release_quality_relay();

  // optional .CMsgSteamDatagramConnectionQuality quality_e2e = 2;
  bool has_quality_e2e() const;
  private:
  bool _internal_has_quality_e2e() const;
  public:
  void clear_quality_e2e();
  const ::CMsgSteamDatagramConnectionQuality& quality_e2e() const;
  PROTOBUF_NODISCARD ::CMsgSteamDatagramConnectionQuality* release_quality_e2e();
  ::CMsgSteamDatagramConnectionQuality* mutable_quality_e2e();
  void set_allocated_quality_e2e(::CMsgSteamDatagramConnectionQuality* quality_e2e);
  private:
  const ::CMsgSteamDatagramConnectionQuality& _internal_quality_e2e() const;
  ::CMsgSteamDatagramConnectionQuality* _internal_mutable_quality_e2e();
  public:
  void unsafe_arena_set_allocated_quality_e2e(
      ::CMsgSteamDatagramConnectionQuality* quality_e2e);
  ::CMsgSteamDatagramConnectionQuality* unsafe_arena_release_quality_e2e();

  // optional uint32 seq_num_s2r = 3;
  bool has_seq_num_s2r() const;
  private:
  bool _internal_has_seq_num_s2r() const;
  public:
  void clear_seq_num_s2r();
  uint32_t seq_num_s2r() const;
  void set_seq_num_s2r(uint32_t value);
  private:
  uint32_t _internal_seq_num_s2r() const;
  void _internal_set_seq_num_s2r(uint32_t value);
  public:

  // optional uint32 seq_num_e2e = 4;
  bool has_seq_num_e2e() const;
  private:
  bool _internal_has_seq_num_e2e() const;
  public:
  void clear_seq_num_e2e();
  uint32_t seq_num_e2e() const;
  void set_seq_num_e2e(uint32_t value);
  private:
  uint32_t _internal_seq_num_e2e() const;
  void _internal_set_seq_num_e2e(uint32_t value);
  public:

  // optional uint32 relay_session_id = 6;
  bool has_relay_session_id() const;
  private:
  bool _internal_has_relay_session_id() const;
  public:
  void clear_relay_session_id();
  uint32_t relay_session_id() const;
  void set_relay_session_id(uint32_t value);
  private:
  uint32_t _internal_relay_session_id() const;
  void _internal_set_relay_session_id(uint32_t value);
  public:

  // optional fixed32 client_connection_id = 7;
  bool has_client_connection_id() const;
  private:
  bool _internal_has_client_connection_id() const;
  public:
  void clear_client_connection_id();
  uint32_t client_connection_id() const;
  void set_client_connection_id(uint32_t value);
  private:
  uint32_t _internal_client_connection_id() const;
  void _internal_set_client_connection_id(uint32_t value);
  public:

  // optional uint32 flags = 10;
  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 fixed32 server_connection_id = 11;
  bool has_server_connection_id() const;
  private:
  bool _internal_has_server_connection_id() const;
  public:
  void clear_server_connection_id();
  uint32_t server_connection_id() const;
  void set_server_connection_id(uint32_t value);
  private:
  uint32_t _internal_server_connection_id() const;
  void _internal_set_server_connection_id(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgSteamDatagramConnectionStatsServerToRouter)
 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< uint32_t > ack_relay_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > legacy_ack_e2e_;
    ::CMsgSteamDatagramConnectionQuality* quality_relay_;
    ::CMsgSteamDatagramConnectionQuality* quality_e2e_;
    uint32_t seq_num_s2r_;
    uint32_t seq_num_e2e_;
    uint32_t relay_session_id_;
    uint32_t client_connection_id_;
    uint32_t flags_;
    uint32_t server_connection_id_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_steamdatagram_5fmessages_5fsdr_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CMsgSteamDatagramP2PSessionRequestBody_EncryptedData& operator=(const CMsgSteamDatagramP2PSessionRequestBody_EncryptedData& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgSteamDatagramP2PSessionRequestBody_EncryptedData& operator=(CMsgSteamDatagramP2PSessionRequestBody_EncryptedData&& 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 CMsgSteamDatagramP2PSessionRequestBody_EncryptedData& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgSteamDatagramP2PSessionRequestBody_EncryptedData* internal_default_instance() {
    return reinterpret_cast<const CMsgSteamDatagramP2PSessionRequestBody_EncryptedData*>(
               &_CMsgSteamDatagramP2PSessionRequestBody_EncryptedData_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    30;

  friend void swap(CMsgSteamDatagramP2PSessionRequestBody_EncryptedData& a, CMsgSteamDatagramP2PSessionRequestBody_EncryptedData& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgSteamDatagramP2PSessionRequestBody_EncryptedData* 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(CMsgSteamDatagramP2PSessionRequestBody_EncryptedData* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CMsgSteamDatagramP2PSessionRequestBody_EncryptedData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgSteamDatagramP2PSessionRequestBody_EncryptedData>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgSteamDatagramP2PSessionRequestBody_EncryptedData& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgSteamDatagramP2PSessionRequestBody_EncryptedData& from) {
    CMsgSteamDatagramP2PSessionRequestBody_EncryptedData::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(CMsgSteamDatagramP2PSessionRequestBody_EncryptedData* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgSteamDatagramP2PSessionRequestBody.EncryptedData";
  }
  protected:
  explicit CMsgSteamDatagramP2PSessionRequestBody_EncryptedData(::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 {
    kPeerIdentityStringFieldNumber = 1,
  };
  // optional string peer_identity_string = 1;
  bool has_peer_identity_string() const;
  private:
  bool _internal_has_peer_identity_string() const;
  public:
  void clear_peer_identity_string();
  const std::string& peer_identity_string() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_peer_identity_string(ArgT0&& arg0, ArgT... args);
  std::string* mutable_peer_identity_string();
  PROTOBUF_NODISCARD std::string* release_peer_identity_string();
  void set_allocated_peer_identity_string(std::string* peer_identity_string);
  private:
  const std::string& _internal_peer_identity_string() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_peer_identity_string(const std::string& value);
  std::string* _internal_mutable_peer_identity_string();
  public:

  // @@protoc_insertion_point(class_scope:CMsgSteamDatagramP2PSessionRequestBody.EncryptedData)
 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 peer_identity_string_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_steamdatagram_5fmessages_5fsdr_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CMsgSteamDatagramP2PSessionRequestBody& operator=(const CMsgSteamDatagramP2PSessionRequestBody& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgSteamDatagramP2PSessionRequestBody& operator=(CMsgSteamDatagramP2PSessionRequestBody&& 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 CMsgSteamDatagramP2PSessionRequestBody& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgSteamDatagramP2PSessionRequestBody* internal_default_instance() {
    return reinterpret_cast<const CMsgSteamDatagramP2PSessionRequestBody*>(
               &_CMsgSteamDatagramP2PSessionRequestBody_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    31;

  friend void swap(CMsgSteamDatagramP2PSessionRequestBody& a, CMsgSteamDatagramP2PSessionRequestBody& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgSteamDatagramP2PSessionRequestBody* 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(CMsgSteamDatagramP2PSessionRequestBody* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CMsgSteamDatagramP2PSessionRequestBody* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgSteamDatagramP2PSessionRequestBody>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgSteamDatagramP2PSessionRequestBody& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgSteamDatagramP2PSessionRequestBody& from) {
    CMsgSteamDatagramP2PSessionRequestBody::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(CMsgSteamDatagramP2PSessionRequestBody* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgSteamDatagramP2PSessionRequestBody";
  }
  protected:
  explicit CMsgSteamDatagramP2PSessionRequestBody(::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 CMsgSteamDatagramP2PSessionRequestBody_EncryptedData EncryptedData;

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

  enum : int {
    kPeerIdentityStringFieldNumber = 11,
    kPlatformFieldNumber = 12,
    kBuildFieldNumber = 13,
    kEncryptedDataFieldNumber = 14,
    kEncryptionMyEphemeralPublicKeyFieldNumber = 16,
    kChallengeFieldNumber = 2,
    kChallengeTimeFieldNumber = 1,
    kClientConnectionIdFieldNumber = 3,
    kLegacyPeerSteamIdFieldNumber = 4,
    kPeerConnectionIdFieldNumber = 5,
    kProtocolVersionFieldNumber = 8,
    kNetworkConfigVersionFieldNumber = 9,
    kEncryptionYourPublicKeyLeadByteFieldNumber = 15,
  };
  // optional string peer_identity_string = 11;
  bool has_peer_identity_string() const;
  private:
  bool _internal_has_peer_identity_string() const;
  public:
  void clear_peer_identity_string();
  const std::string& peer_identity_string() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_peer_identity_string(ArgT0&& arg0, ArgT... args);
  std::string* mutable_peer_identity_string();
  PROTOBUF_NODISCARD std::string* release_peer_identity_string();
  void set_allocated_peer_identity_string(std::string* peer_identity_string);
  private:
  const std::string& _internal_peer_identity_string() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_peer_identity_string(const std::string& value);
  std::string* _internal_mutable_peer_identity_string();
  public:

  // optional string platform = 12;
  bool has_platform() const;
  private:
  bool _internal_has_platform() const;
  public:
  void clear_platform();
  const std::string& platform() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_platform(ArgT0&& arg0, ArgT... args);
  std::string* mutable_platform();
  PROTOBUF_NODISCARD std::string* release_platform();
  void set_allocated_platform(std::string* platform);
  private:
  const std::string& _internal_platform() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_platform(const std::string& value);
  std::string* _internal_mutable_platform();
  public:

  // optional string build = 13;
  bool has_build() const;
  private:
  bool _internal_has_build() const;
  public:
  void clear_build();
  const std::string& build() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_build(ArgT0&& arg0, ArgT... args);
  std::string* mutable_build();
  PROTOBUF_NODISCARD std::string* release_build();
  void set_allocated_build(std::string* build);
  private:
  const std::string& _internal_build() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_build(const std::string& value);
  std::string* _internal_mutable_build();
  public:

  // optional bytes encrypted_data = 14;
  bool has_encrypted_data() const;
  private:
  bool _internal_has_encrypted_data() const;
  public:
  void clear_encrypted_data();
  const std::string& encrypted_data() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_encrypted_data(ArgT0&& arg0, ArgT... args);
  std::string* mutable_encrypted_data();
  PROTOBUF_NODISCARD std::string* release_encrypted_data();
  void set_allocated_encrypted_data(std::string* encrypted_data);
  private:
  const std::string& _internal_encrypted_data() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_encrypted_data(const std::string& value);
  std::string* _internal_mutable_encrypted_data();
  public:

  // optional bytes encryption_my_ephemeral_public_key = 16;
  bool has_encryption_my_ephemeral_public_key() const;
  private:
  bool _internal_has_encryption_my_ephemeral_public_key() const;
  public:
  void clear_encryption_my_ephemeral_public_key();
  const std::string& encryption_my_ephemeral_public_key() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_encryption_my_ephemeral_public_key(ArgT0&& arg0, ArgT... args);
  std::string* mutable_encryption_my_ephemeral_public_key();
  PROTOBUF_NODISCARD std::string* release_encryption_my_ephemeral_public_key();
  void set_allocated_encryption_my_ephemeral_public_key(std::string* encryption_my_ephemeral_public_key);
  private:
  const std::string& _internal_encryption_my_ephemeral_public_key() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_encryption_my_ephemeral_public_key(const std::string& value);
  std::string* _internal_mutable_encryption_my_ephemeral_public_key();
  public:

  // optional fixed64 challenge = 2;
  bool has_challenge() const;
  private:
  bool _internal_has_challenge() const;
  public:
  void clear_challenge();
  uint64_t challenge() const;
  void set_challenge(uint64_t value);
  private:
  uint64_t _internal_challenge() const;
  void _internal_set_challenge(uint64_t value);
  public:

  // optional fixed32 challenge_time = 1;
  bool has_challenge_time() const;
  private:
  bool _internal_has_challenge_time() const;
  public:
  void clear_challenge_time();
  uint32_t challenge_time() const;
  void set_challenge_time(uint32_t value);
  private:
  uint32_t _internal_challenge_time() const;
  void _internal_set_challenge_time(uint32_t value);
  public:

  // optional fixed32 client_connection_id = 3;
  bool has_client_connection_id() const;
  private:
  bool _internal_has_client_connection_id() const;
  public:
  void clear_client_connection_id();
  uint32_t client_connection_id() const;
  void set_client_connection_id(uint32_t value);
  private:
  uint32_t _internal_client_connection_id() const;
  void _internal_set_client_connection_id(uint32_t value);
  public:

  // optional fixed64 legacy_peer_steam_id = 4;
  bool has_legacy_peer_steam_id() const;
  private:
  bool _internal_has_legacy_peer_steam_id() const;
  public:
  void clear_legacy_peer_steam_id();
  uint64_t legacy_peer_steam_id() const;
  void set_legacy_peer_steam_id(uint64_t value);
  private:
  uint64_t _internal_legacy_peer_steam_id() const;
  void _internal_set_legacy_peer_steam_id(uint64_t value);
  public:

  // optional fixed32 peer_connection_id = 5;
  bool has_peer_connection_id() const;
  private:
  bool _internal_has_peer_connection_id() const;
  public:
  void clear_peer_connection_id();
  uint32_t peer_connection_id() const;
  void set_peer_connection_id(uint32_t value);
  private:
  uint32_t _internal_peer_connection_id() const;
  void _internal_set_peer_connection_id(uint32_t value);
  public:

  // optional uint32 protocol_version = 8;
  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 uint64 network_config_version = 9;
  bool has_network_config_version() const;
  private:
  bool _internal_has_network_config_version() const;
  public:
  void clear_network_config_version();
  uint64_t network_config_version() const;
  void set_network_config_version(uint64_t value);
  private:
  uint64_t _internal_network_config_version() const;
  void _internal_set_network_config_version(uint64_t value);
  public:

  // optional uint32 encryption_your_public_key_lead_byte = 15;
  bool has_encryption_your_public_key_lead_byte() const;
  private:
  bool _internal_has_encryption_your_public_key_lead_byte() const;
  public:
  void clear_encryption_your_public_key_lead_byte();
  uint32_t encryption_your_public_key_lead_byte() const;
  void set_encryption_your_public_key_lead_byte(uint32_t value);
  private:
  uint32_t _internal_encryption_your_public_key_lead_byte() const;
  void _internal_set_encryption_your_public_key_lead_byte(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgSteamDatagramP2PSessionRequestBody)
 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 peer_identity_string_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr platform_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr build_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr encrypted_data_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr encryption_my_ephemeral_public_key_;
    uint64_t challenge_;
    uint32_t challenge_time_;
    uint32_t client_connection_id_;
    uint64_t legacy_peer_steam_id_;
    uint32_t peer_connection_id_;
    uint32_t protocol_version_;
    uint64_t network_config_version_;
    uint32_t encryption_your_public_key_lead_byte_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_steamdatagram_5fmessages_5fsdr_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CMsgSteamDatagramP2PSessionRequest& operator=(const CMsgSteamDatagramP2PSessionRequest& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgSteamDatagramP2PSessionRequest& operator=(CMsgSteamDatagramP2PSessionRequest&& 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 CMsgSteamDatagramP2PSessionRequest& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgSteamDatagramP2PSessionRequest* internal_default_instance() {
    return reinterpret_cast<const CMsgSteamDatagramP2PSessionRequest*>(
               &_CMsgSteamDatagramP2PSessionRequest_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    32;

  friend void swap(CMsgSteamDatagramP2PSessionRequest& a, CMsgSteamDatagramP2PSessionRequest& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgSteamDatagramP2PSessionRequest* 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(CMsgSteamDatagramP2PSessionRequest* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CMsgSteamDatagramP2PSessionRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgSteamDatagramP2PSessionRequest>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgSteamDatagramP2PSessionRequest& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgSteamDatagramP2PSessionRequest& from) {
    CMsgSteamDatagramP2PSessionRequest::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(CMsgSteamDatagramP2PSessionRequest* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgSteamDatagramP2PSessionRequest";
  }
  protected:
  explicit CMsgSteamDatagramP2PSessionRequest(::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 {
    kBodyFieldNumber = 2,
    kSignatureFieldNumber = 3,
    kCertFieldNumber = 1,
  };
  // optional bytes body = 2;
  bool has_body() const;
  private:
  bool _internal_has_body() const;
  public:
  void clear_body();
  const std::string& body() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_body(ArgT0&& arg0, ArgT... args);
  std::string* mutable_body();
  PROTOBUF_NODISCARD std::string* release_body();
  void set_allocated_body(std::string* body);
  private:
  const std::string& _internal_body() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_body(const std::string& value);
  std::string* _internal_mutable_body();
  public:

  // optional bytes signature = 3;
  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:

  // optional .CMsgSteamDatagramCertificateSigned cert = 1;
  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:CMsgSteamDatagramP2PSessionRequest)
 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 body_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr signature_;
    ::CMsgSteamDatagramCertificateSigned* cert_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_steamdatagram_5fmessages_5fsdr_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CMsgSteamDatagramP2PSessionEstablished& operator=(const CMsgSteamDatagramP2PSessionEstablished& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgSteamDatagramP2PSessionEstablished& operator=(CMsgSteamDatagramP2PSessionEstablished&& 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 CMsgSteamDatagramP2PSessionEstablished& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgSteamDatagramP2PSessionEstablished* internal_default_instance() {
    return reinterpret_cast<const CMsgSteamDatagramP2PSessionEstablished*>(
               &_CMsgSteamDatagramP2PSessionEstablished_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    33;

  friend void swap(CMsgSteamDatagramP2PSessionEstablished& a, CMsgSteamDatagramP2PSessionEstablished& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgSteamDatagramP2PSessionEstablished* 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(CMsgSteamDatagramP2PSessionEstablished* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CMsgSteamDatagramP2PSessionEstablished* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgSteamDatagramP2PSessionEstablished>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgSteamDatagramP2PSessionEstablished& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgSteamDatagramP2PSessionEstablished& from) {
    CMsgSteamDatagramP2PSessionEstablished::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(CMsgSteamDatagramP2PSessionEstablished* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgSteamDatagramP2PSessionEstablished";
  }
  protected:
  explicit CMsgSteamDatagramP2PSessionEstablished(::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 {
    kRelayRoutingTokenFieldNumber = 4,
    kConnectionIdFieldNumber = 1,
    kSecondsUntilShutdownFieldNumber = 3,
    kSeqNumR2CFieldNumber = 5,
  };
  // optional bytes relay_routing_token = 4;
  bool has_relay_routing_token() const;
  private:
  bool _internal_has_relay_routing_token() const;
  public:
  void clear_relay_routing_token();
  const std::string& relay_routing_token() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_relay_routing_token(ArgT0&& arg0, ArgT... args);
  std::string* mutable_relay_routing_token();
  PROTOBUF_NODISCARD std::string* release_relay_routing_token();
  void set_allocated_relay_routing_token(std::string* relay_routing_token);
  private:
  const std::string& _internal_relay_routing_token() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_relay_routing_token(const std::string& value);
  std::string* _internal_mutable_relay_routing_token();
  public:

  // optional fixed32 connection_id = 1;
  bool has_connection_id() const;
  private:
  bool _internal_has_connection_id() const;
  public:
  void clear_connection_id();
  uint32_t connection_id() const;
  void set_connection_id(uint32_t value);
  private:
  uint32_t _internal_connection_id() const;
  void _internal_set_connection_id(uint32_t value);
  public:

  // optional uint32 seconds_until_shutdown = 3;
  bool has_seconds_until_shutdown() const;
  private:
  bool _internal_has_seconds_until_shutdown() const;
  public:
  void clear_seconds_until_shutdown();
  uint32_t seconds_until_shutdown() const;
  void set_seconds_until_shutdown(uint32_t value);
  private:
  uint32_t _internal_seconds_until_shutdown() const;
  void _internal_set_seconds_until_shutdown(uint32_t value);
  public:

  // optional uint32 seq_num_r2c = 5;
  bool has_seq_num_r2c() const;
  private:
  bool _internal_has_seq_num_r2c() const;
  public:
  void clear_seq_num_r2c();
  uint32_t seq_num_r2c() const;
  void set_seq_num_r2c(uint32_t value);
  private:
  uint32_t _internal_seq_num_r2c() const;
  void _internal_set_seq_num_r2c(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgSteamDatagramP2PSessionEstablished)
 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 relay_routing_token_;
    uint32_t connection_id_;
    uint32_t seconds_until_shutdown_;
    uint32_t seq_num_r2c_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_steamdatagram_5fmessages_5fsdr_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CMsgSteamDatagramConnectionStatsP2PClientToRouter& operator=(const CMsgSteamDatagramConnectionStatsP2PClientToRouter& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgSteamDatagramConnectionStatsP2PClientToRouter& operator=(CMsgSteamDatagramConnectionStatsP2PClientToRouter&& 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 CMsgSteamDatagramConnectionStatsP2PClientToRouter& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgSteamDatagramConnectionStatsP2PClientToRouter* internal_default_instance() {
    return reinterpret_cast<const CMsgSteamDatagramConnectionStatsP2PClientToRouter*>(
               &_CMsgSteamDatagramConnectionStatsP2PClientToRouter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    34;

  friend void swap(CMsgSteamDatagramConnectionStatsP2PClientToRouter& a, CMsgSteamDatagramConnectionStatsP2PClientToRouter& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgSteamDatagramConnectionStatsP2PClientToRouter* 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(CMsgSteamDatagramConnectionStatsP2PClientToRouter* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CMsgSteamDatagramConnectionStatsP2PClientToRouter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgSteamDatagramConnectionStatsP2PClientToRouter>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgSteamDatagramConnectionStatsP2PClientToRouter& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgSteamDatagramConnectionStatsP2PClientToRouter& from) {
    CMsgSteamDatagramConnectionStatsP2PClientToRouter::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(CMsgSteamDatagramConnectionStatsP2PClientToRouter* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgSteamDatagramConnectionStatsP2PClientToRouter";
  }
  protected:
  explicit CMsgSteamDatagramConnectionStatsP2PClientToRouter(::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 CMsgSteamDatagramConnectionStatsP2PClientToRouter_Flags Flags;
  static constexpr Flags ACK_REQUEST_RELAY =
    CMsgSteamDatagramConnectionStatsP2PClientToRouter_Flags_ACK_REQUEST_RELAY;
  static constexpr Flags ACK_REQUEST_E2E =
    CMsgSteamDatagramConnectionStatsP2PClientToRouter_Flags_ACK_REQUEST_E2E;
  static constexpr Flags ACK_REQUEST_IMMEDIATE =
    CMsgSteamDatagramConnectionStatsP2PClientToRouter_Flags_ACK_REQUEST_IMMEDIATE;
  static constexpr Flags NOT_PRIMARY_SESSION =
    CMsgSteamDatagramConnectionStatsP2PClientToRouter_Flags_NOT_PRIMARY_SESSION;
  static constexpr Flags NOT_PRIMARY_TRANSPORT_E2E =
    CMsgSteamDatagramConnectionStatsP2PClientToRouter_Flags_NOT_PRIMARY_TRANSPORT_E2E;
  static constexpr Flags CLIENT_RELAY_OVERRIDE =
    CMsgSteamDatagramConnectionStatsP2PClientToRouter_Flags_CLIENT_RELAY_OVERRIDE;
  static inline bool Flags_IsValid(int value) {
    return CMsgSteamDatagramConnectionStatsP2PClientToRouter_Flags_IsValid(value);
  }
  static constexpr Flags Flags_MIN =
    CMsgSteamDatagramConnectionStatsP2PClientToRouter_Flags_Flags_MIN;
  static constexpr Flags Flags_MAX =
    CMsgSteamDatagramConnectionStatsP2PClientToRouter_Flags_Flags_MAX;
  static constexpr int Flags_ARRAYSIZE =
    CMsgSteamDatagramConnectionStatsP2PClientToRouter_Flags_Flags_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  Flags_descriptor() {
    return CMsgSteamDatagramConnectionStatsP2PClientToRouter_Flags_descriptor();
  }
  template<typename T>
  static inline const std::string& Flags_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Flags>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Flags_Name.");
    return CMsgSteamDatagramConnectionStatsP2PClientToRouter_Flags_Name(enum_t_value);
  }
  static inline bool Flags_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Flags* value) {
    return CMsgSteamDatagramConnectionStatsP2PClientToRouter_Flags_Parse(name, value);
  }

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

  enum : int {
    kAckRelayFieldNumber = 3,
    kLegacyAckE2EFieldNumber = 4,
    kForwardTargetRelayRoutingTokenFieldNumber = 6,
    kRoutesFieldNumber = 8,
    kQualityRelayFieldNumber = 1,
    kQualityE2EFieldNumber = 2,
    kP2PRoutingSummaryFieldNumber = 14,
    kFlagsFieldNumber = 5,
    kForwardTargetRevisionFieldNumber = 7,
    kAckPeerRoutesRevisionFieldNumber = 9,
    kConnectionIdFieldNumber = 10,
    kSeqNumC2RFieldNumber = 11,
    kSeqNumE2EFieldNumber = 12,
  };
  // repeated fixed32 ack_relay = 3;
  int ack_relay_size() const;
  private:
  int _internal_ack_relay_size() const;
  public:
  void clear_ack_relay();
  private:
  uint32_t _internal_ack_relay(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      _internal_ack_relay() const;
  void _internal_add_ack_relay(uint32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      _internal_mutable_ack_relay();
  public:
  uint32_t ack_relay(int index) const;
  void set_ack_relay(int index, uint32_t value);
  void add_ack_relay(uint32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      ack_relay() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      mutable_ack_relay();

  // repeated fixed32 legacy_ack_e2e = 4;
  int legacy_ack_e2e_size() const;
  private:
  int _internal_legacy_ack_e2e_size() const;
  public:
  void clear_legacy_ack_e2e();
  private:
  uint32_t _internal_legacy_ack_e2e(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      _internal_legacy_ack_e2e() const;
  void _internal_add_legacy_ack_e2e(uint32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      _internal_mutable_legacy_ack_e2e();
  public:
  uint32_t legacy_ack_e2e(int index) const;
  void set_legacy_ack_e2e(int index, uint32_t value);
  void add_legacy_ack_e2e(uint32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      legacy_ack_e2e() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      mutable_legacy_ack_e2e();

  // optional bytes forward_target_relay_routing_token = 6;
  bool has_forward_target_relay_routing_token() const;
  private:
  bool _internal_has_forward_target_relay_routing_token() const;
  public:
  void clear_forward_target_relay_routing_token();
  const std::string& forward_target_relay_routing_token() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_forward_target_relay_routing_token(ArgT0&& arg0, ArgT... args);
  std::string* mutable_forward_target_relay_routing_token();
  PROTOBUF_NODISCARD std::string* release_forward_target_relay_routing_token();
  void set_allocated_forward_target_relay_routing_token(std::string* forward_target_relay_routing_token);
  private:
  const std::string& _internal_forward_target_relay_routing_token() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_forward_target_relay_routing_token(const std::string& value);
  std::string* _internal_mutable_forward_target_relay_routing_token();
  public:

  // optional bytes routes = 8;
  bool has_routes() const;
  private:
  bool _internal_has_routes() const;
  public:
  void clear_routes();
  const std::string& routes() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_routes(ArgT0&& arg0, ArgT... args);
  std::string* mutable_routes();
  PROTOBUF_NODISCARD std::string* release_routes();
  void set_allocated_routes(std::string* routes);
  private:
  const std::string& _internal_routes() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_routes(const std::string& value);
  std::string* _internal_mutable_routes();
  public:

  // optional .CMsgSteamDatagramConnectionQuality quality_relay = 1;
  bool has_quality_relay() const;
  private:
  bool _internal_has_quality_relay() const;
  public:
  void clear_quality_relay();
  const ::CMsgSteamDatagramConnectionQuality& quality_relay() const;
  PROTOBUF_NODISCARD ::CMsgSteamDatagramConnectionQuality* release_quality_relay();
  ::CMsgSteamDatagramConnectionQuality* mutable_quality_relay();
  void set_allocated_quality_relay(::CMsgSteamDatagramConnectionQuality* quality_relay);
  private:
  const ::CMsgSteamDatagramConnectionQuality& _internal_quality_relay() const;
  ::CMsgSteamDatagramConnectionQuality* _internal_mutable_quality_relay();
  public:
  void unsafe_arena_set_allocated_quality_relay(
      ::CMsgSteamDatagramConnectionQuality* quality_relay);
  ::CMsgSteamDatagramConnectionQuality* unsafe_arena_release_quality_relay();

  // optional .CMsgSteamDatagramConnectionQuality quality_e2e = 2;
  bool has_quality_e2e() const;
  private:
  bool _internal_has_quality_e2e() const;
  public:
  void clear_quality_e2e();
  const ::CMsgSteamDatagramConnectionQuality& quality_e2e() const;
  PROTOBUF_NODISCARD ::CMsgSteamDatagramConnectionQuality* release_quality_e2e();
  ::CMsgSteamDatagramConnectionQuality* mutable_quality_e2e();
  void set_allocated_quality_e2e(::CMsgSteamDatagramConnectionQuality* quality_e2e);
  private:
  const ::CMsgSteamDatagramConnectionQuality& _internal_quality_e2e() const;
  ::CMsgSteamDatagramConnectionQuality* _internal_mutable_quality_e2e();
  public:
  void unsafe_arena_set_allocated_quality_e2e(
      ::CMsgSteamDatagramConnectionQuality* quality_e2e);
  ::CMsgSteamDatagramConnectionQuality* unsafe_arena_release_quality_e2e();

  // optional .CMsgSteamDatagramP2PRoutingSummary p2p_routing_summary = 14;
  bool has_p2p_routing_summary() const;
  private:
  bool _internal_has_p2p_routing_summary() const;
  public:
  void clear_p2p_routing_summary();
  const ::CMsgSteamDatagramP2PRoutingSummary& p2p_routing_summary() const;
  PROTOBUF_NODISCARD ::CMsgSteamDatagramP2PRoutingSummary* release_p2p_routing_summary();
  ::CMsgSteamDatagramP2PRoutingSummary* mutable_p2p_routing_summary();
  void set_allocated_p2p_routing_summary(::CMsgSteamDatagramP2PRoutingSummary* p2p_routing_summary);
  private:
  const ::CMsgSteamDatagramP2PRoutingSummary& _internal_p2p_routing_summary() const;
  ::CMsgSteamDatagramP2PRoutingSummary* _internal_mutable_p2p_routing_summary();
  public:
  void unsafe_arena_set_allocated_p2p_routing_summary(
      ::CMsgSteamDatagramP2PRoutingSummary* p2p_routing_summary);
  ::CMsgSteamDatagramP2PRoutingSummary* unsafe_arena_release_p2p_routing_summary();

  // optional uint32 flags = 5;
  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 forward_target_revision = 7;
  bool has_forward_target_revision() const;
  private:
  bool _internal_has_forward_target_revision() const;
  public:
  void clear_forward_target_revision();
  uint32_t forward_target_revision() const;
  void set_forward_target_revision(uint32_t value);
  private:
  uint32_t _internal_forward_target_revision() const;
  void _internal_set_forward_target_revision(uint32_t value);
  public:

  // optional uint32 ack_peer_routes_revision = 9;
  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 fixed32 connection_id = 10;
  bool has_connection_id() const;
  private:
  bool _internal_has_connection_id() const;
  public:
  void clear_connection_id();
  uint32_t connection_id() const;
  void set_connection_id(uint32_t value);
  private:
  uint32_t _internal_connection_id() const;
  void _internal_set_connection_id(uint32_t value);
  public:

  // optional uint32 seq_num_c2r = 11;
  bool has_seq_num_c2r() const;
  private:
  bool _internal_has_seq_num_c2r() const;
  public:
  void clear_seq_num_c2r();
  uint32_t seq_num_c2r() const;
  void set_seq_num_c2r(uint32_t value);
  private:
  uint32_t _internal_seq_num_c2r() const;
  void _internal_set_seq_num_c2r(uint32_t value);
  public:

  // optional uint32 seq_num_e2e = 12;
  bool has_seq_num_e2e() const;
  private:
  bool _internal_has_seq_num_e2e() const;
  public:
  void clear_seq_num_e2e();
  uint32_t seq_num_e2e() const;
  void set_seq_num_e2e(uint32_t value);
  private:
  uint32_t _internal_seq_num_e2e() const;
  void _internal_set_seq_num_e2e(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgSteamDatagramConnectionStatsP2PClientToRouter)
 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< uint32_t > ack_relay_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > legacy_ack_e2e_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr forward_target_relay_routing_token_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr routes_;
    ::CMsgSteamDatagramConnectionQuality* quality_relay_;
    ::CMsgSteamDatagramConnectionQuality* quality_e2e_;
    ::CMsgSteamDatagramP2PRoutingSummary* p2p_routing_summary_;
    uint32_t flags_;
    uint32_t forward_target_revision_;
    uint32_t ack_peer_routes_revision_;
    uint32_t connection_id_;
    uint32_t seq_num_c2r_;
    uint32_t seq_num_e2e_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_steamdatagram_5fmessages_5fsdr_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CMsgSteamDatagramConnectionStatsP2PRouterToClient& operator=(const CMsgSteamDatagramConnectionStatsP2PRouterToClient& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgSteamDatagramConnectionStatsP2PRouterToClient& operator=(CMsgSteamDatagramConnectionStatsP2PRouterToClient&& 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 CMsgSteamDatagramConnectionStatsP2PRouterToClient& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgSteamDatagramConnectionStatsP2PRouterToClient* internal_default_instance() {
    return reinterpret_cast<const CMsgSteamDatagramConnectionStatsP2PRouterToClient*>(
               &_CMsgSteamDatagramConnectionStatsP2PRouterToClient_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    35;

  friend void swap(CMsgSteamDatagramConnectionStatsP2PRouterToClient& a, CMsgSteamDatagramConnectionStatsP2PRouterToClient& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgSteamDatagramConnectionStatsP2PRouterToClient* 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(CMsgSteamDatagramConnectionStatsP2PRouterToClient* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CMsgSteamDatagramConnectionStatsP2PRouterToClient* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgSteamDatagramConnectionStatsP2PRouterToClient>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgSteamDatagramConnectionStatsP2PRouterToClient& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgSteamDatagramConnectionStatsP2PRouterToClient& from) {
    CMsgSteamDatagramConnectionStatsP2PRouterToClient::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(CMsgSteamDatagramConnectionStatsP2PRouterToClient* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgSteamDatagramConnectionStatsP2PRouterToClient";
  }
  protected:
  explicit CMsgSteamDatagramConnectionStatsP2PRouterToClient(::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 CMsgSteamDatagramConnectionStatsP2PRouterToClient_Flags Flags;
  static constexpr Flags ACK_REQUEST_RELAY =
    CMsgSteamDatagramConnectionStatsP2PRouterToClient_Flags_ACK_REQUEST_RELAY;
  static constexpr Flags ACK_REQUEST_E2E =
    CMsgSteamDatagramConnectionStatsP2PRouterToClient_Flags_ACK_REQUEST_E2E;
  static constexpr Flags ACK_REQUEST_IMMEDIATE =
    CMsgSteamDatagramConnectionStatsP2PRouterToClient_Flags_ACK_REQUEST_IMMEDIATE;
  static constexpr Flags NOT_PRIMARY_TRANSPORT_E2E =
    CMsgSteamDatagramConnectionStatsP2PRouterToClient_Flags_NOT_PRIMARY_TRANSPORT_E2E;
  static inline bool Flags_IsValid(int value) {
    return CMsgSteamDatagramConnectionStatsP2PRouterToClient_Flags_IsValid(value);
  }
  static constexpr Flags Flags_MIN =
    CMsgSteamDatagramConnectionStatsP2PRouterToClient_Flags_Flags_MIN;
  static constexpr Flags Flags_MAX =
    CMsgSteamDatagramConnectionStatsP2PRouterToClient_Flags_Flags_MAX;
  static constexpr int Flags_ARRAYSIZE =
    CMsgSteamDatagramConnectionStatsP2PRouterToClient_Flags_Flags_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  Flags_descriptor() {
    return CMsgSteamDatagramConnectionStatsP2PRouterToClient_Flags_descriptor();
  }
  template<typename T>
  static inline const std::string& Flags_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Flags>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Flags_Name.");
    return CMsgSteamDatagramConnectionStatsP2PRouterToClient_Flags_Name(enum_t_value);
  }
  static inline bool Flags_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Flags* value) {
    return CMsgSteamDatagramConnectionStatsP2PRouterToClient_Flags_Parse(name, value);
  }

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

  enum : int {
    kAckRelayFieldNumber = 7,
    kLegacyAckE2EFieldNumber = 8,
    kRoutesFieldNumber = 11,
    kQualityRelayFieldNumber = 1,
    kQualityE2EFieldNumber = 2,
    kSecondsUntilShutdownFieldNumber = 3,
    kMigrateRequestIpFieldNumber = 4,
    kMigrateRequestPortFieldNumber = 5,
    kScoringPenaltyRelayClusterFieldNumber = 6,
    kFlagsFieldNumber = 9,
    kAckForwardTargetRevisionFieldNumber = 10,
    kAckPeerRoutesRevisionFieldNumber = 12,
    kConnectionIdFieldNumber = 13,
    kSeqNumR2CFieldNumber = 14,
    kSeqNumE2EFieldNumber = 15,
  };
  // repeated fixed32 ack_relay = 7;
  int ack_relay_size() const;
  private:
  int _internal_ack_relay_size() const;
  public:
  void clear_ack_relay();
  private:
  uint32_t _internal_ack_relay(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      _internal_ack_relay() const;
  void _internal_add_ack_relay(uint32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      _internal_mutable_ack_relay();
  public:
  uint32_t ack_relay(int index) const;
  void set_ack_relay(int index, uint32_t value);
  void add_ack_relay(uint32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      ack_relay() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      mutable_ack_relay();

  // repeated fixed32 legacy_ack_e2e = 8;
  int legacy_ack_e2e_size() const;
  private:
  int _internal_legacy_ack_e2e_size() const;
  public:
  void clear_legacy_ack_e2e();
  private:
  uint32_t _internal_legacy_ack_e2e(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      _internal_legacy_ack_e2e() const;
  void _internal_add_legacy_ack_e2e(uint32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      _internal_mutable_legacy_ack_e2e();
  public:
  uint32_t legacy_ack_e2e(int index) const;
  void set_legacy_ack_e2e(int index, uint32_t value);
  void add_legacy_ack_e2e(uint32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
      legacy_ack_e2e() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
      mutable_legacy_ack_e2e();

  // optional bytes routes = 11;
  bool has_routes() const;
  private:
  bool _internal_has_routes() const;
  public:
  void clear_routes();
  const std::string& routes() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_routes(ArgT0&& arg0, ArgT... args);
  std::string* mutable_routes();
  PROTOBUF_NODISCARD std::string* release_routes();
  void set_allocated_routes(std::string* routes);
  private:
  const std::string& _internal_routes() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_routes(const std::string& value);
  std::string* _internal_mutable_routes();
  public:

  // optional .CMsgSteamDatagramConnectionQuality quality_relay = 1;
  bool has_quality_relay() const;
  private:
  bool _internal_has_quality_relay() const;
  public:
  void clear_quality_relay();
  const ::CMsgSteamDatagramConnectionQuality& quality_relay() const;
  PROTOBUF_NODISCARD ::CMsgSteamDatagramConnectionQuality* release_quality_relay();
  ::CMsgSteamDatagramConnectionQuality* mutable_quality_relay();
  void set_allocated_quality_relay(::CMsgSteamDatagramConnectionQuality* quality_relay);
  private:
  const ::CMsgSteamDatagramConnectionQuality& _internal_quality_relay() const;
  ::CMsgSteamDatagramConnectionQuality* _internal_mutable_quality_relay();
  public:
  void unsafe_arena_set_allocated_quality_relay(
      ::CMsgSteamDatagramConnectionQuality* quality_relay);
  ::CMsgSteamDatagramConnectionQuality* unsafe_arena_release_quality_relay();

  // optional .CMsgSteamDatagramConnectionQuality quality_e2e = 2;
  bool has_quality_e2e() const;
  private:
  bool _internal_has_quality_e2e() const;
  public:
  void clear_quality_e2e();
  const ::CMsgSteamDatagramConnectionQuality& quality_e2e() const;
  PROTOBUF_NODISCARD ::CMsgSteamDatagramConnectionQuality* release_quality_e2e();
  ::CMsgSteamDatagramConnectionQuality* mutable_quality_e2e();
  void set_allocated_quality_e2e(::CMsgSteamDatagramConnectionQuality* quality_e2e);
  private:
  const ::CMsgSteamDatagramConnectionQuality& _internal_quality_e2e() const;
  ::CMsgSteamDatagramConnectionQuality* _internal_mutable_quality_e2e();
  public:
  void unsafe_arena_set_allocated_quality_e2e(
      ::CMsgSteamDatagramConnectionQuality* quality_e2e);
  ::CMsgSteamDatagramConnectionQuality* unsafe_arena_release_quality_e2e();

  // optional uint32 seconds_until_shutdown = 3;
  bool has_seconds_until_shutdown() const;
  private:
  bool _internal_has_seconds_until_shutdown() const;
  public:
  void clear_seconds_until_shutdown();
  uint32_t seconds_until_shutdown() const;
  void set_seconds_until_shutdown(uint32_t value);
  private:
  uint32_t _internal_seconds_until_shutdown() const;
  void _internal_set_seconds_until_shutdown(uint32_t value);
  public:

  // optional fixed32 migrate_request_ip = 4;
  bool has_migrate_request_ip() const;
  private:
  bool _internal_has_migrate_request_ip() const;
  public:
  void clear_migrate_request_ip();
  uint32_t migrate_request_ip() const;
  void set_migrate_request_ip(uint32_t value);
  private:
  uint32_t _internal_migrate_request_ip() const;
  void _internal_set_migrate_request_ip(uint32_t value);
  public:

  // optional uint32 migrate_request_port = 5;
  bool has_migrate_request_port() const;
  private:
  bool _internal_has_migrate_request_port() const;
  public:
  void clear_migrate_request_port();
  uint32_t migrate_request_port() const;
  void set_migrate_request_port(uint32_t value);
  private:
  uint32_t _internal_migrate_request_port() const;
  void _internal_set_migrate_request_port(uint32_t value);
  public:

  // optional uint32 scoring_penalty_relay_cluster = 6;
  bool has_scoring_penalty_relay_cluster() const;
  private:
  bool _internal_has_scoring_penalty_relay_cluster() const;
  public:
  void clear_scoring_penalty_relay_cluster();
  uint32_t scoring_penalty_relay_cluster() const;
  void set_scoring_penalty_relay_cluster(uint32_t value);
  private:
  uint32_t _internal_scoring_penalty_relay_cluster() const;
  void _internal_set_scoring_penalty_relay_cluster(uint32_t value);
  public:

  // optional uint32 flags = 9;
  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 ack_forward_target_revision = 10;
  bool has_ack_forward_target_revision() const;
  private:
  bool _internal_has_ack_forward_target_revision() const;
  public:
  void clear_ack_forward_target_revision();
  uint32_t ack_forward_target_revision() const;
  void set_ack_forward_target_revision(uint32_t value);
  private:
  uint32_t _internal_ack_forward_target_revision() const;
  void _internal_set_ack_forward_target_revision(uint32_t value);
  public:

  // optional uint32 ack_peer_routes_revision = 12;
  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 fixed32 connection_id = 13;
  bool has_connection_id() const;
  private:
  bool _internal_has_connection_id() const;
  public:
  void clear_connection_id();
  uint32_t connection_id() const;
  void set_connection_id(uint32_t value);
  private:
  uint32_t _internal_connection_id() const;
  void _internal_set_connection_id(uint32_t value);
  public:

  // optional uint32 seq_num_r2c = 14;
  bool has_seq_num_r2c() const;
  private:
  bool _internal_has_seq_num_r2c() const;
  public:
  void clear_seq_num_r2c();
  uint32_t seq_num_r2c() const;
  void set_seq_num_r2c(uint32_t value);
  private:
  uint32_t _internal_seq_num_r2c() const;
  void _internal_set_seq_num_r2c(uint32_t value);
  public:

  // optional uint32 seq_num_e2e = 15;
  bool has_seq_num_e2e() const;
  private:
  bool _internal_has_seq_num_e2e() const;
  public:
  void clear_seq_num_e2e();
  uint32_t seq_num_e2e() const;
  void set_seq_num_e2e(uint32_t value);
  private:
  uint32_t _internal_seq_num_e2e() const;
  void _internal_set_seq_num_e2e(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgSteamDatagramConnectionStatsP2PRouterToClient)
 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< uint32_t > ack_relay_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > legacy_ack_e2e_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr routes_;
    ::CMsgSteamDatagramConnectionQuality* quality_relay_;
    ::CMsgSteamDatagramConnectionQuality* quality_e2e_;
    uint32_t seconds_until_shutdown_;
    uint32_t migrate_request_ip_;
    uint32_t migrate_request_port_;
    uint32_t scoring_penalty_relay_cluster_;
    uint32_t flags_;
    uint32_t ack_forward_target_revision_;
    uint32_t ack_peer_routes_revision_;
    uint32_t connection_id_;
    uint32_t seq_num_r2c_;
    uint32_t seq_num_e2e_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_steamdatagram_5fmessages_5fsdr_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CMsgSteamDatagramP2PBadRouteRouterToClient& operator=(const CMsgSteamDatagramP2PBadRouteRouterToClient& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgSteamDatagramP2PBadRouteRouterToClient& operator=(CMsgSteamDatagramP2PBadRouteRouterToClient&& 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 CMsgSteamDatagramP2PBadRouteRouterToClient& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgSteamDatagramP2PBadRouteRouterToClient* internal_default_instance() {
    return reinterpret_cast<const CMsgSteamDatagramP2PBadRouteRouterToClient*>(
               &_CMsgSteamDatagramP2PBadRouteRouterToClient_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    36;

  friend void swap(CMsgSteamDatagramP2PBadRouteRouterToClient& a, CMsgSteamDatagramP2PBadRouteRouterToClient& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgSteamDatagramP2PBadRouteRouterToClient* 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(CMsgSteamDatagramP2PBadRouteRouterToClient* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CMsgSteamDatagramP2PBadRouteRouterToClient* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgSteamDatagramP2PBadRouteRouterToClient>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgSteamDatagramP2PBadRouteRouterToClient& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgSteamDatagramP2PBadRouteRouterToClient& from) {
    CMsgSteamDatagramP2PBadRouteRouterToClient::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(CMsgSteamDatagramP2PBadRouteRouterToClient* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgSteamDatagramP2PBadRouteRouterToClient";
  }
  protected:
  explicit CMsgSteamDatagramP2PBadRouteRouterToClient(::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 {
    kFailedRelayRoutingTokenFieldNumber = 2,
    kConnectionIdFieldNumber = 1,
    kAckForwardTargetRevisionFieldNumber = 3,
    kKludgePadFieldNumber = 99,
  };
  // optional bytes failed_relay_routing_token = 2;
  bool has_failed_relay_routing_token() const;
  private:
  bool _internal_has_failed_relay_routing_token() const;
  public:
  void clear_failed_relay_routing_token();
  const std::string& failed_relay_routing_token() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_failed_relay_routing_token(ArgT0&& arg0, ArgT... args);
  std::string* mutable_failed_relay_routing_token();
  PROTOBUF_NODISCARD std::string* release_failed_relay_routing_token();
  void set_allocated_failed_relay_routing_token(std::string* failed_relay_routing_token);
  private:
  const std::string& _internal_failed_relay_routing_token() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_failed_relay_routing_token(const std::string& value);
  std::string* _internal_mutable_failed_relay_routing_token();
  public:

  // optional fixed32 connection_id = 1;
  bool has_connection_id() const;
  private:
  bool _internal_has_connection_id() const;
  public:
  void clear_connection_id();
  uint32_t connection_id() const;
  void set_connection_id(uint32_t value);
  private:
  uint32_t _internal_connection_id() const;
  void _internal_set_connection_id(uint32_t value);
  public:

  // optional uint32 ack_forward_target_revision = 3;
  bool has_ack_forward_target_revision() const;
  private:
  bool _internal_has_ack_forward_target_revision() const;
  public:
  void clear_ack_forward_target_revision();
  uint32_t ack_forward_target_revision() const;
  void set_ack_forward_target_revision(uint32_t value);
  private:
  uint32_t _internal_ack_forward_target_revision() const;
  void _internal_set_ack_forward_target_revision(uint32_t value);
  public:

  // optional fixed64 kludge_pad = 99;
  bool has_kludge_pad() const;
  private:
  bool _internal_has_kludge_pad() const;
  public:
  void clear_kludge_pad();
  uint64_t kludge_pad() const;
  void set_kludge_pad(uint64_t value);
  private:
  uint64_t _internal_kludge_pad() const;
  void _internal_set_kludge_pad(uint64_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgSteamDatagramP2PBadRouteRouterToClient)
 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 failed_relay_routing_token_;
    uint32_t connection_id_;
    uint32_t ack_forward_target_revision_;
    uint64_t kludge_pad_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_steamdatagram_5fmessages_5fsdr_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CMsgSteamDatagramP2PRoutes_RelayCluster& operator=(const CMsgSteamDatagramP2PRoutes_RelayCluster& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgSteamDatagramP2PRoutes_RelayCluster& operator=(CMsgSteamDatagramP2PRoutes_RelayCluster&& 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 CMsgSteamDatagramP2PRoutes_RelayCluster& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgSteamDatagramP2PRoutes_RelayCluster* internal_default_instance() {
    return reinterpret_cast<const CMsgSteamDatagramP2PRoutes_RelayCluster*>(
               &_CMsgSteamDatagramP2PRoutes_RelayCluster_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    37;

  friend void swap(CMsgSteamDatagramP2PRoutes_RelayCluster& a, CMsgSteamDatagramP2PRoutes_RelayCluster& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgSteamDatagramP2PRoutes_RelayCluster* 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(CMsgSteamDatagramP2PRoutes_RelayCluster* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CMsgSteamDatagramP2PRoutes_RelayCluster* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgSteamDatagramP2PRoutes_RelayCluster>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgSteamDatagramP2PRoutes_RelayCluster& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgSteamDatagramP2PRoutes_RelayCluster& from) {
    CMsgSteamDatagramP2PRoutes_RelayCluster::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(CMsgSteamDatagramP2PRoutes_RelayCluster* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgSteamDatagramP2PRoutes.RelayCluster";
  }
  protected:
  explicit CMsgSteamDatagramP2PRoutes_RelayCluster(::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 {
    kSessionRelayRoutingTokenFieldNumber = 4,
    kPopIdFieldNumber = 1,
    kPingMsFieldNumber = 2,
    kScorePenaltyFieldNumber = 3,
  };
  // optional bytes session_relay_routing_token = 4;
  bool has_session_relay_routing_token() const;
  private:
  bool _internal_has_session_relay_routing_token() const;
  public:
  void clear_session_relay_routing_token();
  const std::string& session_relay_routing_token() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_session_relay_routing_token(ArgT0&& arg0, ArgT... args);
  std::string* mutable_session_relay_routing_token();
  PROTOBUF_NODISCARD std::string* release_session_relay_routing_token();
  void set_allocated_session_relay_routing_token(std::string* session_relay_routing_token);
  private:
  const std::string& _internal_session_relay_routing_token() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_session_relay_routing_token(const std::string& value);
  std::string* _internal_mutable_session_relay_routing_token();
  public:

  // optional fixed32 pop_id = 1;
  bool has_pop_id() const;
  private:
  bool _internal_has_pop_id() const;
  public:
  void clear_pop_id();
  uint32_t pop_id() const;
  void set_pop_id(uint32_t value);
  private:
  uint32_t _internal_pop_id() const;
  void _internal_set_pop_id(uint32_t value);
  public:

  // optional uint32 ping_ms = 2;
  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 score_penalty = 3;
  bool has_score_penalty() const;
  private:
  bool _internal_has_score_penalty() const;
  public:
  void clear_score_penalty();
  uint32_t score_penalty() const;
  void set_score_penalty(uint32_t value);
  private:
  uint32_t _internal_score_penalty() const;
  void _internal_set_score_penalty(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgSteamDatagramP2PRoutes.RelayCluster)
 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 session_relay_routing_token_;
    uint32_t pop_id_;
    uint32_t ping_ms_;
    uint32_t score_penalty_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_steamdatagram_5fmessages_5fsdr_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CMsgSteamDatagramP2PRoutes_Route& operator=(const CMsgSteamDatagramP2PRoutes_Route& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgSteamDatagramP2PRoutes_Route& operator=(CMsgSteamDatagramP2PRoutes_Route&& 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 CMsgSteamDatagramP2PRoutes_Route& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgSteamDatagramP2PRoutes_Route* internal_default_instance() {
    return reinterpret_cast<const CMsgSteamDatagramP2PRoutes_Route*>(
               &_CMsgSteamDatagramP2PRoutes_Route_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    38;

  friend void swap(CMsgSteamDatagramP2PRoutes_Route& a, CMsgSteamDatagramP2PRoutes_Route& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgSteamDatagramP2PRoutes_Route* 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(CMsgSteamDatagramP2PRoutes_Route* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CMsgSteamDatagramP2PRoutes_Route* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgSteamDatagramP2PRoutes_Route>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgSteamDatagramP2PRoutes_Route& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgSteamDatagramP2PRoutes_Route& from) {
    CMsgSteamDatagramP2PRoutes_Route::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(CMsgSteamDatagramP2PRoutes_Route* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgSteamDatagramP2PRoutes.Route";
  }
  protected:
  explicit CMsgSteamDatagramP2PRoutes_Route(::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 {
    kMyPopIdFieldNumber = 1,
    kYourPopIdFieldNumber = 2,
    kLegacyScoreFieldNumber = 3,
    kInteriorScoreFieldNumber = 4,
  };
  // optional fixed32 my_pop_id = 1;
  bool has_my_pop_id() const;
  private:
  bool _internal_has_my_pop_id() const;
  public:
  void clear_my_pop_id();
  uint32_t my_pop_id() const;
  void set_my_pop_id(uint32_t value);
  private:
  uint32_t _internal_my_pop_id() const;
  void _internal_set_my_pop_id(uint32_t value);
  public:

  // optional fixed32 your_pop_id = 2;
  bool has_your_pop_id() const;
  private:
  bool _internal_has_your_pop_id() const;
  public:
  void clear_your_pop_id();
  uint32_t your_pop_id() const;
  void set_your_pop_id(uint32_t value);
  private:
  uint32_t _internal_your_pop_id() const;
  void _internal_set_your_pop_id(uint32_t value);
  public:

  // optional uint32 legacy_score = 3;
  bool has_legacy_score() const;
  private:
  bool _internal_has_legacy_score() const;
  public:
  void clear_legacy_score();
  uint32_t legacy_score() const;
  void set_legacy_score(uint32_t value);
  private:
  uint32_t _internal_legacy_score() const;
  void _internal_set_legacy_score(uint32_t value);
  public:

  // optional uint32 interior_score = 4;
  bool has_interior_score() const;
  private:
  bool _internal_has_interior_score() const;
  public:
  void clear_interior_score();
  uint32_t interior_score() const;
  void set_interior_score(uint32_t value);
  private:
  uint32_t _internal_interior_score() const;
  void _internal_set_interior_score(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgSteamDatagramP2PRoutes.Route)
 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 my_pop_id_;
    uint32_t your_pop_id_;
    uint32_t legacy_score_;
    uint32_t interior_score_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_steamdatagram_5fmessages_5fsdr_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CMsgSteamDatagramP2PRoutes& operator=(const CMsgSteamDatagramP2PRoutes& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgSteamDatagramP2PRoutes& operator=(CMsgSteamDatagramP2PRoutes&& 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 CMsgSteamDatagramP2PRoutes& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgSteamDatagramP2PRoutes* internal_default_instance() {
    return reinterpret_cast<const CMsgSteamDatagramP2PRoutes*>(
               &_CMsgSteamDatagramP2PRoutes_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    39;

  friend void swap(CMsgSteamDatagramP2PRoutes& a, CMsgSteamDatagramP2PRoutes& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgSteamDatagramP2PRoutes* 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(CMsgSteamDatagramP2PRoutes* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CMsgSteamDatagramP2PRoutes* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgSteamDatagramP2PRoutes>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgSteamDatagramP2PRoutes& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgSteamDatagramP2PRoutes& from) {
    CMsgSteamDatagramP2PRoutes::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(CMsgSteamDatagramP2PRoutes* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgSteamDatagramP2PRoutes";
  }
  protected:
  explicit CMsgSteamDatagramP2PRoutes(::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 CMsgSteamDatagramP2PRoutes_RelayCluster RelayCluster;
  typedef CMsgSteamDatagramP2PRoutes_Route Route;

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

  enum : int {
    kRelayClustersFieldNumber = 1,
    kRoutesFieldNumber = 2,
    kRevisionFieldNumber = 3,
  };
  // repeated .CMsgSteamDatagramP2PRoutes.RelayCluster relay_clusters = 1;
  int relay_clusters_size() const;
  private:
  int _internal_relay_clusters_size() const;
  public:
  void clear_relay_clusters();
  ::CMsgSteamDatagramP2PRoutes_RelayCluster* mutable_relay_clusters(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgSteamDatagramP2PRoutes_RelayCluster >*
      mutable_relay_clusters();
  private:
  const ::CMsgSteamDatagramP2PRoutes_RelayCluster& _internal_relay_clusters(int index) const;
  ::CMsgSteamDatagramP2PRoutes_RelayCluster* _internal_add_relay_clusters();
  public:
  const ::CMsgSteamDatagramP2PRoutes_RelayCluster& relay_clusters(int index) const;
  ::CMsgSteamDatagramP2PRoutes_RelayCluster* add_relay_clusters();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgSteamDatagramP2PRoutes_RelayCluster >&
      relay_clusters() const;

  // repeated .CMsgSteamDatagramP2PRoutes.Route routes = 2;
  int routes_size() const;
  private:
  int _internal_routes_size() const;
  public:
  void clear_routes();
  ::CMsgSteamDatagramP2PRoutes_Route* mutable_routes(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgSteamDatagramP2PRoutes_Route >*
      mutable_routes();
  private:
  const ::CMsgSteamDatagramP2PRoutes_Route& _internal_routes(int index) const;
  ::CMsgSteamDatagramP2PRoutes_Route* _internal_add_routes();
  public:
  const ::CMsgSteamDatagramP2PRoutes_Route& routes(int index) const;
  ::CMsgSteamDatagramP2PRoutes_Route* add_routes();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgSteamDatagramP2PRoutes_Route >&
      routes() const;

  // optional uint32 revision = 3;
  bool has_revision() const;
  private:
  bool _internal_has_revision() const;
  public:
  void clear_revision();
  uint32_t revision() const;
  void set_revision(uint32_t value);
  private:
  uint32_t _internal_revision() const;
  void _internal_set_revision(uint32_t value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgSteamDatagramP2PRoutes)
 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< ::CMsgSteamDatagramP2PRoutes_RelayCluster > relay_clusters_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgSteamDatagramP2PRoutes_Route > routes_;
    uint32_t revision_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_steamdatagram_5fmessages_5fsdr_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CMsgSteamDatagramSetSecondaryAddressRequest& operator=(const CMsgSteamDatagramSetSecondaryAddressRequest& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgSteamDatagramSetSecondaryAddressRequest& operator=(CMsgSteamDatagramSetSecondaryAddressRequest&& 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 CMsgSteamDatagramSetSecondaryAddressRequest& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgSteamDatagramSetSecondaryAddressRequest* internal_default_instance() {
    return reinterpret_cast<const CMsgSteamDatagramSetSecondaryAddressRequest*>(
               &_CMsgSteamDatagramSetSecondaryAddressRequest_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    40;

  friend void swap(CMsgSteamDatagramSetSecondaryAddressRequest& a, CMsgSteamDatagramSetSecondaryAddressRequest& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgSteamDatagramSetSecondaryAddressRequest* 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(CMsgSteamDatagramSetSecondaryAddressRequest* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CMsgSteamDatagramSetSecondaryAddressRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgSteamDatagramSetSecondaryAddressRequest>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgSteamDatagramSetSecondaryAddressRequest& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgSteamDatagramSetSecondaryAddressRequest& from) {
    CMsgSteamDatagramSetSecondaryAddressRequest::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(CMsgSteamDatagramSetSecondaryAddressRequest* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgSteamDatagramSetSecondaryAddressRequest";
  }
  protected:
  explicit CMsgSteamDatagramSetSecondaryAddressRequest(::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 {
    kClientIdentityFieldNumber = 4,
    kKludgePadFieldNumber = 99,
    kClientMainIpFieldNumber = 1,
    kClientMainPortFieldNumber = 2,
    kClientConnectionIdFieldNumber = 3,
    kRequestSendDuplicationFieldNumber = 5,
  };
  // optional string client_identity = 4;
  bool has_client_identity() const;
  private:
  bool _internal_has_client_identity() const;
  public:
  void clear_client_identity();
  const std::string& client_identity() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_client_identity(ArgT0&& arg0, ArgT... args);
  std::string* mutable_client_identity();
  PROTOBUF_NODISCARD std::string* release_client_identity();
  void set_allocated_client_identity(std::string* client_identity);
  private:
  const std::string& _internal_client_identity() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_client_identity(const std::string& value);
  std::string* _internal_mutable_client_identity();
  public:

  // optional bytes kludge_pad = 99;
  bool has_kludge_pad() const;
  private:
  bool _internal_has_kludge_pad() const;
  public:
  void clear_kludge_pad();
  const std::string& kludge_pad() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_kludge_pad(ArgT0&& arg0, ArgT... args);
  std::string* mutable_kludge_pad();
  PROTOBUF_NODISCARD std::string* release_kludge_pad();
  void set_allocated_kludge_pad(std::string* kludge_pad);
  private:
  const std::string& _internal_kludge_pad() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_kludge_pad(const std::string& value);
  std::string* _internal_mutable_kludge_pad();
  public:

  // optional fixed32 client_main_ip = 1;
  bool has_client_main_ip() const;
  private:
  bool _internal_has_client_main_ip() const;
  public:
  void clear_client_main_ip();
  uint32_t client_main_ip() const;
  void set_client_main_ip(uint32_t value);
  private:
  uint32_t _internal_client_main_ip() const;
  void _internal_set_client_main_ip(uint32_t value);
  public:

  // optional fixed32 client_main_port = 2;
  bool has_client_main_port() const;
  private:
  bool _internal_has_client_main_port() const;
  public:
  void clear_client_main_port();
  uint32_t client_main_port() const;
  void set_client_main_port(uint32_t value);
  private:
  uint32_t _internal_client_main_port() const;
  void _internal_set_client_main_port(uint32_t value);
  public:

  // optional fixed32 client_connection_id = 3;
  bool has_client_connection_id() const;
  private:
  bool _internal_has_client_connection_id() const;
  public:
  void clear_client_connection_id();
  uint32_t client_connection_id() const;
  void set_client_connection_id(uint32_t value);
  private:
  uint32_t _internal_client_connection_id() const;
  void _internal_set_client_connection_id(uint32_t value);
  public:

  // optional bool request_send_duplication = 5;
  bool has_request_send_duplication() const;
  private:
  bool _internal_has_request_send_duplication() const;
  public:
  void clear_request_send_duplication();
  bool request_send_duplication() const;
  void set_request_send_duplication(bool value);
  private:
  bool _internal_request_send_duplication() const;
  void _internal_set_request_send_duplication(bool value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgSteamDatagramSetSecondaryAddressRequest)
 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 client_identity_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr kludge_pad_;
    uint32_t client_main_ip_;
    uint32_t client_main_port_;
    uint32_t client_connection_id_;
    bool request_send_duplication_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_steamdatagram_5fmessages_5fsdr_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline CMsgSteamDatagramSetSecondaryAddressResult& operator=(const CMsgSteamDatagramSetSecondaryAddressResult& from) {
    CopyFrom(from);
    return *this;
  }
  inline CMsgSteamDatagramSetSecondaryAddressResult& operator=(CMsgSteamDatagramSetSecondaryAddressResult&& 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 CMsgSteamDatagramSetSecondaryAddressResult& default_instance() {
    return *internal_default_instance();
  }
  static inline const CMsgSteamDatagramSetSecondaryAddressResult* internal_default_instance() {
    return reinterpret_cast<const CMsgSteamDatagramSetSecondaryAddressResult*>(
               &_CMsgSteamDatagramSetSecondaryAddressResult_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    41;

  friend void swap(CMsgSteamDatagramSetSecondaryAddressResult& a, CMsgSteamDatagramSetSecondaryAddressResult& b) {
    a.Swap(&b);
  }
  inline void Swap(CMsgSteamDatagramSetSecondaryAddressResult* 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(CMsgSteamDatagramSetSecondaryAddressResult* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CMsgSteamDatagramSetSecondaryAddressResult* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CMsgSteamDatagramSetSecondaryAddressResult>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CMsgSteamDatagramSetSecondaryAddressResult& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom( const CMsgSteamDatagramSetSecondaryAddressResult& from) {
    CMsgSteamDatagramSetSecondaryAddressResult::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(CMsgSteamDatagramSetSecondaryAddressResult* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "CMsgSteamDatagramSetSecondaryAddressResult";
  }
  protected:
  explicit CMsgSteamDatagramSetSecondaryAddressResult(::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 {
    kMessageFieldNumber = 2,
    kSuccessFieldNumber = 1,
  };
  // optional string message = 2;
  bool has_message() const;
  private:
  bool _internal_has_message() const;
  public:
  void clear_message();
  const std::string& message() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_message(ArgT0&& arg0, ArgT... args);
  std::string* mutable_message();
  PROTOBUF_NODISCARD std::string* release_message();
  void set_allocated_message(std::string* message);
  private:
  const std::string& _internal_message() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_message(const std::string& value);
  std::string* _internal_mutable_message();
  public:

  // optional bool success = 1;
  bool has_success() const;
  private:
  bool _internal_has_success() const;
  public:
  void clear_success();
  bool success() const;
  void set_success(bool value);
  private:
  bool _internal_success() const;
  void _internal_set_success(bool value);
  public:

  // @@protoc_insertion_point(class_scope:CMsgSteamDatagramSetSecondaryAddressResult)
 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 message_;
    bool success_;
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_steamdatagram_5fmessages_5fsdr_2eproto;
};
// ===================================================================


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

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

// optional fixed32 v4 = 1;
inline bool CMsgSteamNetworkingIPAddress::_internal_has_v4() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgSteamNetworkingIPAddress::has_v4() const {
  return _internal_has_v4();
}
inline void CMsgSteamNetworkingIPAddress::clear_v4() {
  _impl_.v4_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t CMsgSteamNetworkingIPAddress::_internal_v4() const {
  return _impl_.v4_;
}
inline uint32_t CMsgSteamNetworkingIPAddress::v4() const {
  // @@protoc_insertion_point(field_get:CMsgSteamNetworkingIPAddress.v4)
  return _internal_v4();
}
inline void CMsgSteamNetworkingIPAddress::_internal_set_v4(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.v4_ = value;
}
inline void CMsgSteamNetworkingIPAddress::set_v4(uint32_t value) {
  _internal_set_v4(value);
  // @@protoc_insertion_point(field_set:CMsgSteamNetworkingIPAddress.v4)
}

// optional bytes v6 = 2;
inline bool CMsgSteamNetworkingIPAddress::_internal_has_v6() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgSteamNetworkingIPAddress::has_v6() const {
  return _internal_has_v6();
}
inline void CMsgSteamNetworkingIPAddress::clear_v6() {
  _impl_.v6_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CMsgSteamNetworkingIPAddress::v6() const {
  // @@protoc_insertion_point(field_get:CMsgSteamNetworkingIPAddress.v6)
  return _internal_v6();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgSteamNetworkingIPAddress::set_v6(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.v6_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgSteamNetworkingIPAddress.v6)
}
inline std::string* CMsgSteamNetworkingIPAddress::mutable_v6() {
  std::string* _s = _internal_mutable_v6();
  // @@protoc_insertion_point(field_mutable:CMsgSteamNetworkingIPAddress.v6)
  return _s;
}
inline const std::string& CMsgSteamNetworkingIPAddress::_internal_v6() const {
  return _impl_.v6_.Get();
}
inline void CMsgSteamNetworkingIPAddress::_internal_set_v6(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.v6_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgSteamNetworkingIPAddress::_internal_mutable_v6() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.v6_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgSteamNetworkingIPAddress::release_v6() {
  // @@protoc_insertion_point(field_release:CMsgSteamNetworkingIPAddress.v6)
  if (!_internal_has_v6()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.v6_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.v6_.IsDefault()) {
    _impl_.v6_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgSteamNetworkingIPAddress::set_allocated_v6(std::string* v6) {
  if (v6 != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.v6_.SetAllocated(v6, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.v6_.IsDefault()) {
    _impl_.v6_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamNetworkingIPAddress.v6)
}

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

// CMsgSteamDatagramSignedMessageGeneric

// optional .CMsgSteamDatagramCertificateSigned cert = 1;
inline bool CMsgSteamDatagramSignedMessageGeneric::_internal_has_cert() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.cert_ != nullptr);
  return value;
}
inline bool CMsgSteamDatagramSignedMessageGeneric::has_cert() const {
  return _internal_has_cert();
}
inline const ::CMsgSteamDatagramCertificateSigned& CMsgSteamDatagramSignedMessageGeneric::_internal_cert() const {
  const ::CMsgSteamDatagramCertificateSigned* p = _impl_.cert_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgSteamDatagramCertificateSigned&>(
      ::_CMsgSteamDatagramCertificateSigned_default_instance_);
}
inline const ::CMsgSteamDatagramCertificateSigned& CMsgSteamDatagramSignedMessageGeneric::cert() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramSignedMessageGeneric.cert)
  return _internal_cert();
}
inline void CMsgSteamDatagramSignedMessageGeneric::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] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgSteamDatagramSignedMessageGeneric.cert)
}
inline ::CMsgSteamDatagramCertificateSigned* CMsgSteamDatagramSignedMessageGeneric::release_cert() {
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::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* CMsgSteamDatagramSignedMessageGeneric::unsafe_arena_release_cert() {
  // @@protoc_insertion_point(field_release:CMsgSteamDatagramSignedMessageGeneric.cert)
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::CMsgSteamDatagramCertificateSigned* temp = _impl_.cert_;
  _impl_.cert_ = nullptr;
  return temp;
}
inline ::CMsgSteamDatagramCertificateSigned* CMsgSteamDatagramSignedMessageGeneric::_internal_mutable_cert() {
  _impl_._has_bits_[0] |= 0x00000008u;
  if (_impl_.cert_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgSteamDatagramCertificateSigned>(GetArenaForAllocation());
    _impl_.cert_ = p;
  }
  return _impl_.cert_;
}
inline ::CMsgSteamDatagramCertificateSigned* CMsgSteamDatagramSignedMessageGeneric::mutable_cert() {
  ::CMsgSteamDatagramCertificateSigned* _msg = _internal_mutable_cert();
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramSignedMessageGeneric.cert)
  return _msg;
}
inline void CMsgSteamDatagramSignedMessageGeneric::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] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.cert_ = cert;
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamDatagramSignedMessageGeneric.cert)
}

// optional bytes signed_data = 2;
inline bool CMsgSteamDatagramSignedMessageGeneric::_internal_has_signed_data() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgSteamDatagramSignedMessageGeneric::has_signed_data() const {
  return _internal_has_signed_data();
}
inline void CMsgSteamDatagramSignedMessageGeneric::clear_signed_data() {
  _impl_.signed_data_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CMsgSteamDatagramSignedMessageGeneric::signed_data() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramSignedMessageGeneric.signed_data)
  return _internal_signed_data();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgSteamDatagramSignedMessageGeneric::set_signed_data(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.signed_data_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramSignedMessageGeneric.signed_data)
}
inline std::string* CMsgSteamDatagramSignedMessageGeneric::mutable_signed_data() {
  std::string* _s = _internal_mutable_signed_data();
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramSignedMessageGeneric.signed_data)
  return _s;
}
inline const std::string& CMsgSteamDatagramSignedMessageGeneric::_internal_signed_data() const {
  return _impl_.signed_data_.Get();
}
inline void CMsgSteamDatagramSignedMessageGeneric::_internal_set_signed_data(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.signed_data_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramSignedMessageGeneric::_internal_mutable_signed_data() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.signed_data_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramSignedMessageGeneric::release_signed_data() {
  // @@protoc_insertion_point(field_release:CMsgSteamDatagramSignedMessageGeneric.signed_data)
  if (!_internal_has_signed_data()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.signed_data_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.signed_data_.IsDefault()) {
    _impl_.signed_data_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgSteamDatagramSignedMessageGeneric::set_allocated_signed_data(std::string* signed_data) {
  if (signed_data != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.signed_data_.SetAllocated(signed_data, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.signed_data_.IsDefault()) {
    _impl_.signed_data_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamDatagramSignedMessageGeneric.signed_data)
}

// optional bytes signature = 3;
inline bool CMsgSteamDatagramSignedMessageGeneric::_internal_has_signature() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgSteamDatagramSignedMessageGeneric::has_signature() const {
  return _internal_has_signature();
}
inline void CMsgSteamDatagramSignedMessageGeneric::clear_signature() {
  _impl_.signature_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& CMsgSteamDatagramSignedMessageGeneric::signature() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramSignedMessageGeneric.signature)
  return _internal_signature();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgSteamDatagramSignedMessageGeneric::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:CMsgSteamDatagramSignedMessageGeneric.signature)
}
inline std::string* CMsgSteamDatagramSignedMessageGeneric::mutable_signature() {
  std::string* _s = _internal_mutable_signature();
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramSignedMessageGeneric.signature)
  return _s;
}
inline const std::string& CMsgSteamDatagramSignedMessageGeneric::_internal_signature() const {
  return _impl_.signature_.Get();
}
inline void CMsgSteamDatagramSignedMessageGeneric::_internal_set_signature(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.signature_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramSignedMessageGeneric::_internal_mutable_signature() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.signature_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramSignedMessageGeneric::release_signature() {
  // @@protoc_insertion_point(field_release:CMsgSteamDatagramSignedMessageGeneric.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 CMsgSteamDatagramSignedMessageGeneric::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:CMsgSteamDatagramSignedMessageGeneric.signature)
}

// optional bytes dummy_pad = 1023;
inline bool CMsgSteamDatagramSignedMessageGeneric::_internal_has_dummy_pad() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgSteamDatagramSignedMessageGeneric::has_dummy_pad() const {
  return _internal_has_dummy_pad();
}
inline void CMsgSteamDatagramSignedMessageGeneric::clear_dummy_pad() {
  _impl_.dummy_pad_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& CMsgSteamDatagramSignedMessageGeneric::dummy_pad() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramSignedMessageGeneric.dummy_pad)
  return _internal_dummy_pad();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgSteamDatagramSignedMessageGeneric::set_dummy_pad(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.dummy_pad_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramSignedMessageGeneric.dummy_pad)
}
inline std::string* CMsgSteamDatagramSignedMessageGeneric::mutable_dummy_pad() {
  std::string* _s = _internal_mutable_dummy_pad();
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramSignedMessageGeneric.dummy_pad)
  return _s;
}
inline const std::string& CMsgSteamDatagramSignedMessageGeneric::_internal_dummy_pad() const {
  return _impl_.dummy_pad_.Get();
}
inline void CMsgSteamDatagramSignedMessageGeneric::_internal_set_dummy_pad(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.dummy_pad_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramSignedMessageGeneric::_internal_mutable_dummy_pad() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.dummy_pad_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramSignedMessageGeneric::release_dummy_pad() {
  // @@protoc_insertion_point(field_release:CMsgSteamDatagramSignedMessageGeneric.dummy_pad)
  if (!_internal_has_dummy_pad()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* p = _impl_.dummy_pad_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.dummy_pad_.IsDefault()) {
    _impl_.dummy_pad_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgSteamDatagramSignedMessageGeneric::set_allocated_dummy_pad(std::string* dummy_pad) {
  if (dummy_pad != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.dummy_pad_.SetAllocated(dummy_pad, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.dummy_pad_.IsDefault()) {
    _impl_.dummy_pad_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamDatagramSignedMessageGeneric.dummy_pad)
}

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

// CMsgSteamDatagramRouterPingReply_RouteException

// optional fixed32 data_center_id = 1;
inline bool CMsgSteamDatagramRouterPingReply_RouteException::_internal_has_data_center_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgSteamDatagramRouterPingReply_RouteException::has_data_center_id() const {
  return _internal_has_data_center_id();
}
inline void CMsgSteamDatagramRouterPingReply_RouteException::clear_data_center_id() {
  _impl_.data_center_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t CMsgSteamDatagramRouterPingReply_RouteException::_internal_data_center_id() const {
  return _impl_.data_center_id_;
}
inline uint32_t CMsgSteamDatagramRouterPingReply_RouteException::data_center_id() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramRouterPingReply.RouteException.data_center_id)
  return _internal_data_center_id();
}
inline void CMsgSteamDatagramRouterPingReply_RouteException::_internal_set_data_center_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.data_center_id_ = value;
}
inline void CMsgSteamDatagramRouterPingReply_RouteException::set_data_center_id(uint32_t value) {
  _internal_set_data_center_id(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramRouterPingReply.RouteException.data_center_id)
}

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

// optional uint32 penalty = 3;
inline bool CMsgSteamDatagramRouterPingReply_RouteException::_internal_has_penalty() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgSteamDatagramRouterPingReply_RouteException::has_penalty() const {
  return _internal_has_penalty();
}
inline void CMsgSteamDatagramRouterPingReply_RouteException::clear_penalty() {
  _impl_.penalty_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t CMsgSteamDatagramRouterPingReply_RouteException::_internal_penalty() const {
  return _impl_.penalty_;
}
inline uint32_t CMsgSteamDatagramRouterPingReply_RouteException::penalty() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramRouterPingReply.RouteException.penalty)
  return _internal_penalty();
}
inline void CMsgSteamDatagramRouterPingReply_RouteException::_internal_set_penalty(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.penalty_ = value;
}
inline void CMsgSteamDatagramRouterPingReply_RouteException::set_penalty(uint32_t value) {
  _internal_set_penalty(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramRouterPingReply.RouteException.penalty)
}

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

// CMsgSteamDatagramRouterPingReply_AltAddress

// optional fixed32 ipv4 = 1;
inline bool CMsgSteamDatagramRouterPingReply_AltAddress::_internal_has_ipv4() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgSteamDatagramRouterPingReply_AltAddress::has_ipv4() const {
  return _internal_has_ipv4();
}
inline void CMsgSteamDatagramRouterPingReply_AltAddress::clear_ipv4() {
  _impl_.ipv4_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t CMsgSteamDatagramRouterPingReply_AltAddress::_internal_ipv4() const {
  return _impl_.ipv4_;
}
inline uint32_t CMsgSteamDatagramRouterPingReply_AltAddress::ipv4() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramRouterPingReply.AltAddress.ipv4)
  return _internal_ipv4();
}
inline void CMsgSteamDatagramRouterPingReply_AltAddress::_internal_set_ipv4(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.ipv4_ = value;
}
inline void CMsgSteamDatagramRouterPingReply_AltAddress::set_ipv4(uint32_t value) {
  _internal_set_ipv4(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramRouterPingReply.AltAddress.ipv4)
}

// optional uint32 port = 2;
inline bool CMsgSteamDatagramRouterPingReply_AltAddress::_internal_has_port() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgSteamDatagramRouterPingReply_AltAddress::has_port() const {
  return _internal_has_port();
}
inline void CMsgSteamDatagramRouterPingReply_AltAddress::clear_port() {
  _impl_.port_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t CMsgSteamDatagramRouterPingReply_AltAddress::_internal_port() const {
  return _impl_.port_;
}
inline uint32_t CMsgSteamDatagramRouterPingReply_AltAddress::port() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramRouterPingReply.AltAddress.port)
  return _internal_port();
}
inline void CMsgSteamDatagramRouterPingReply_AltAddress::_internal_set_port(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.port_ = value;
}
inline void CMsgSteamDatagramRouterPingReply_AltAddress::set_port(uint32_t value) {
  _internal_set_port(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramRouterPingReply.AltAddress.port)
}

// optional uint32 penalty = 3;
inline bool CMsgSteamDatagramRouterPingReply_AltAddress::_internal_has_penalty() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CMsgSteamDatagramRouterPingReply_AltAddress::has_penalty() const {
  return _internal_has_penalty();
}
inline void CMsgSteamDatagramRouterPingReply_AltAddress::clear_penalty() {
  _impl_.penalty_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t CMsgSteamDatagramRouterPingReply_AltAddress::_internal_penalty() const {
  return _impl_.penalty_;
}
inline uint32_t CMsgSteamDatagramRouterPingReply_AltAddress::penalty() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramRouterPingReply.AltAddress.penalty)
  return _internal_penalty();
}
inline void CMsgSteamDatagramRouterPingReply_AltAddress::_internal_set_penalty(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.penalty_ = value;
}
inline void CMsgSteamDatagramRouterPingReply_AltAddress::set_penalty(uint32_t value) {
  _internal_set_penalty(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramRouterPingReply.AltAddress.penalty)
}

// optional .CMsgSteamDatagramRouterPingReply.AltAddress.Protocol protocol = 4 [default = DefaultProtocol];
inline bool CMsgSteamDatagramRouterPingReply_AltAddress::_internal_has_protocol() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CMsgSteamDatagramRouterPingReply_AltAddress::has_protocol() const {
  return _internal_has_protocol();
}
inline void CMsgSteamDatagramRouterPingReply_AltAddress::clear_protocol() {
  _impl_.protocol_ = 0;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline ::CMsgSteamDatagramRouterPingReply_AltAddress_Protocol CMsgSteamDatagramRouterPingReply_AltAddress::_internal_protocol() const {
  return static_cast< ::CMsgSteamDatagramRouterPingReply_AltAddress_Protocol >(_impl_.protocol_);
}
inline ::CMsgSteamDatagramRouterPingReply_AltAddress_Protocol CMsgSteamDatagramRouterPingReply_AltAddress::protocol() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramRouterPingReply.AltAddress.protocol)
  return _internal_protocol();
}
inline void CMsgSteamDatagramRouterPingReply_AltAddress::_internal_set_protocol(::CMsgSteamDatagramRouterPingReply_AltAddress_Protocol value) {
  assert(::CMsgSteamDatagramRouterPingReply_AltAddress_Protocol_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.protocol_ = value;
}
inline void CMsgSteamDatagramRouterPingReply_AltAddress::set_protocol(::CMsgSteamDatagramRouterPingReply_AltAddress_Protocol value) {
  _internal_set_protocol(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramRouterPingReply.AltAddress.protocol)
}

// optional string id = 5;
inline bool CMsgSteamDatagramRouterPingReply_AltAddress::_internal_has_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgSteamDatagramRouterPingReply_AltAddress::has_id() const {
  return _internal_has_id();
}
inline void CMsgSteamDatagramRouterPingReply_AltAddress::clear_id() {
  _impl_.id_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CMsgSteamDatagramRouterPingReply_AltAddress::id() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramRouterPingReply.AltAddress.id)
  return _internal_id();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgSteamDatagramRouterPingReply_AltAddress::set_id(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.id_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramRouterPingReply.AltAddress.id)
}
inline std::string* CMsgSteamDatagramRouterPingReply_AltAddress::mutable_id() {
  std::string* _s = _internal_mutable_id();
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramRouterPingReply.AltAddress.id)
  return _s;
}
inline const std::string& CMsgSteamDatagramRouterPingReply_AltAddress::_internal_id() const {
  return _impl_.id_.Get();
}
inline void CMsgSteamDatagramRouterPingReply_AltAddress::_internal_set_id(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.id_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramRouterPingReply_AltAddress::_internal_mutable_id() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.id_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramRouterPingReply_AltAddress::release_id() {
  // @@protoc_insertion_point(field_release:CMsgSteamDatagramRouterPingReply.AltAddress.id)
  if (!_internal_has_id()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.id_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.id_.IsDefault()) {
    _impl_.id_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgSteamDatagramRouterPingReply_AltAddress::set_allocated_id(std::string* id) {
  if (id != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.id_.SetAllocated(id, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.id_.IsDefault()) {
    _impl_.id_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamDatagramRouterPingReply.AltAddress.id)
}

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

// CMsgSteamDatagramRouterPingReply

// optional fixed32 client_timestamp = 1;
inline bool CMsgSteamDatagramRouterPingReply::_internal_has_client_timestamp() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgSteamDatagramRouterPingReply::has_client_timestamp() const {
  return _internal_has_client_timestamp();
}
inline void CMsgSteamDatagramRouterPingReply::clear_client_timestamp() {
  _impl_.client_timestamp_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t CMsgSteamDatagramRouterPingReply::_internal_client_timestamp() const {
  return _impl_.client_timestamp_;
}
inline uint32_t CMsgSteamDatagramRouterPingReply::client_timestamp() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramRouterPingReply.client_timestamp)
  return _internal_client_timestamp();
}
inline void CMsgSteamDatagramRouterPingReply::_internal_set_client_timestamp(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.client_timestamp_ = value;
}
inline void CMsgSteamDatagramRouterPingReply::set_client_timestamp(uint32_t value) {
  _internal_set_client_timestamp(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramRouterPingReply.client_timestamp)
}

// repeated fixed32 latency_datacenter_ids = 2 [packed = true];
inline int CMsgSteamDatagramRouterPingReply::_internal_latency_datacenter_ids_size() const {
  return _impl_.latency_datacenter_ids_.size();
}
inline int CMsgSteamDatagramRouterPingReply::latency_datacenter_ids_size() const {
  return _internal_latency_datacenter_ids_size();
}
inline void CMsgSteamDatagramRouterPingReply::clear_latency_datacenter_ids() {
  _impl_.latency_datacenter_ids_.Clear();
}
inline uint32_t CMsgSteamDatagramRouterPingReply::_internal_latency_datacenter_ids(int index) const {
  return _impl_.latency_datacenter_ids_.Get(index);
}
inline uint32_t CMsgSteamDatagramRouterPingReply::latency_datacenter_ids(int index) const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramRouterPingReply.latency_datacenter_ids)
  return _internal_latency_datacenter_ids(index);
}
inline void CMsgSteamDatagramRouterPingReply::set_latency_datacenter_ids(int index, uint32_t value) {
  _impl_.latency_datacenter_ids_.Set(index, value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramRouterPingReply.latency_datacenter_ids)
}
inline void CMsgSteamDatagramRouterPingReply::_internal_add_latency_datacenter_ids(uint32_t value) {
  _impl_.latency_datacenter_ids_.Add(value);
}
inline void CMsgSteamDatagramRouterPingReply::add_latency_datacenter_ids(uint32_t value) {
  _internal_add_latency_datacenter_ids(value);
  // @@protoc_insertion_point(field_add:CMsgSteamDatagramRouterPingReply.latency_datacenter_ids)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
CMsgSteamDatagramRouterPingReply::_internal_latency_datacenter_ids() const {
  return _impl_.latency_datacenter_ids_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
CMsgSteamDatagramRouterPingReply::latency_datacenter_ids() const {
  // @@protoc_insertion_point(field_list:CMsgSteamDatagramRouterPingReply.latency_datacenter_ids)
  return _internal_latency_datacenter_ids();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
CMsgSteamDatagramRouterPingReply::_internal_mutable_latency_datacenter_ids() {
  return &_impl_.latency_datacenter_ids_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
CMsgSteamDatagramRouterPingReply::mutable_latency_datacenter_ids() {
  // @@protoc_insertion_point(field_mutable_list:CMsgSteamDatagramRouterPingReply.latency_datacenter_ids)
  return _internal_mutable_latency_datacenter_ids();
}

// repeated uint32 latency_ping_ms = 3 [packed = true];
inline int CMsgSteamDatagramRouterPingReply::_internal_latency_ping_ms_size() const {
  return _impl_.latency_ping_ms_.size();
}
inline int CMsgSteamDatagramRouterPingReply::latency_ping_ms_size() const {
  return _internal_latency_ping_ms_size();
}
inline void CMsgSteamDatagramRouterPingReply::clear_latency_ping_ms() {
  _impl_.latency_ping_ms_.Clear();
}
inline uint32_t CMsgSteamDatagramRouterPingReply::_internal_latency_ping_ms(int index) const {
  return _impl_.latency_ping_ms_.Get(index);
}
inline uint32_t CMsgSteamDatagramRouterPingReply::latency_ping_ms(int index) const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramRouterPingReply.latency_ping_ms)
  return _internal_latency_ping_ms(index);
}
inline void CMsgSteamDatagramRouterPingReply::set_latency_ping_ms(int index, uint32_t value) {
  _impl_.latency_ping_ms_.Set(index, value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramRouterPingReply.latency_ping_ms)
}
inline void CMsgSteamDatagramRouterPingReply::_internal_add_latency_ping_ms(uint32_t value) {
  _impl_.latency_ping_ms_.Add(value);
}
inline void CMsgSteamDatagramRouterPingReply::add_latency_ping_ms(uint32_t value) {
  _internal_add_latency_ping_ms(value);
  // @@protoc_insertion_point(field_add:CMsgSteamDatagramRouterPingReply.latency_ping_ms)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
CMsgSteamDatagramRouterPingReply::_internal_latency_ping_ms() const {
  return _impl_.latency_ping_ms_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
CMsgSteamDatagramRouterPingReply::latency_ping_ms() const {
  // @@protoc_insertion_point(field_list:CMsgSteamDatagramRouterPingReply.latency_ping_ms)
  return _internal_latency_ping_ms();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
CMsgSteamDatagramRouterPingReply::_internal_mutable_latency_ping_ms() {
  return &_impl_.latency_ping_ms_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
CMsgSteamDatagramRouterPingReply::mutable_latency_ping_ms() {
  // @@protoc_insertion_point(field_mutable_list:CMsgSteamDatagramRouterPingReply.latency_ping_ms)
  return _internal_mutable_latency_ping_ms();
}

// repeated fixed32 latency_datacenter_ids_p2p = 14 [packed = true];
inline int CMsgSteamDatagramRouterPingReply::_internal_latency_datacenter_ids_p2p_size() const {
  return _impl_.latency_datacenter_ids_p2p_.size();
}
inline int CMsgSteamDatagramRouterPingReply::latency_datacenter_ids_p2p_size() const {
  return _internal_latency_datacenter_ids_p2p_size();
}
inline void CMsgSteamDatagramRouterPingReply::clear_latency_datacenter_ids_p2p() {
  _impl_.latency_datacenter_ids_p2p_.Clear();
}
inline uint32_t CMsgSteamDatagramRouterPingReply::_internal_latency_datacenter_ids_p2p(int index) const {
  return _impl_.latency_datacenter_ids_p2p_.Get(index);
}
inline uint32_t CMsgSteamDatagramRouterPingReply::latency_datacenter_ids_p2p(int index) const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramRouterPingReply.latency_datacenter_ids_p2p)
  return _internal_latency_datacenter_ids_p2p(index);
}
inline void CMsgSteamDatagramRouterPingReply::set_latency_datacenter_ids_p2p(int index, uint32_t value) {
  _impl_.latency_datacenter_ids_p2p_.Set(index, value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramRouterPingReply.latency_datacenter_ids_p2p)
}
inline void CMsgSteamDatagramRouterPingReply::_internal_add_latency_datacenter_ids_p2p(uint32_t value) {
  _impl_.latency_datacenter_ids_p2p_.Add(value);
}
inline void CMsgSteamDatagramRouterPingReply::add_latency_datacenter_ids_p2p(uint32_t value) {
  _internal_add_latency_datacenter_ids_p2p(value);
  // @@protoc_insertion_point(field_add:CMsgSteamDatagramRouterPingReply.latency_datacenter_ids_p2p)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
CMsgSteamDatagramRouterPingReply::_internal_latency_datacenter_ids_p2p() const {
  return _impl_.latency_datacenter_ids_p2p_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
CMsgSteamDatagramRouterPingReply::latency_datacenter_ids_p2p() const {
  // @@protoc_insertion_point(field_list:CMsgSteamDatagramRouterPingReply.latency_datacenter_ids_p2p)
  return _internal_latency_datacenter_ids_p2p();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
CMsgSteamDatagramRouterPingReply::_internal_mutable_latency_datacenter_ids_p2p() {
  return &_impl_.latency_datacenter_ids_p2p_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
CMsgSteamDatagramRouterPingReply::mutable_latency_datacenter_ids_p2p() {
  // @@protoc_insertion_point(field_mutable_list:CMsgSteamDatagramRouterPingReply.latency_datacenter_ids_p2p)
  return _internal_mutable_latency_datacenter_ids_p2p();
}

// repeated uint32 latency_ping_ms_p2p = 15 [packed = true];
inline int CMsgSteamDatagramRouterPingReply::_internal_latency_ping_ms_p2p_size() const {
  return _impl_.latency_ping_ms_p2p_.size();
}
inline int CMsgSteamDatagramRouterPingReply::latency_ping_ms_p2p_size() const {
  return _internal_latency_ping_ms_p2p_size();
}
inline void CMsgSteamDatagramRouterPingReply::clear_latency_ping_ms_p2p() {
  _impl_.latency_ping_ms_p2p_.Clear();
}
inline uint32_t CMsgSteamDatagramRouterPingReply::_internal_latency_ping_ms_p2p(int index) const {
  return _impl_.latency_ping_ms_p2p_.Get(index);
}
inline uint32_t CMsgSteamDatagramRouterPingReply::latency_ping_ms_p2p(int index) const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramRouterPingReply.latency_ping_ms_p2p)
  return _internal_latency_ping_ms_p2p(index);
}
inline void CMsgSteamDatagramRouterPingReply::set_latency_ping_ms_p2p(int index, uint32_t value) {
  _impl_.latency_ping_ms_p2p_.Set(index, value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramRouterPingReply.latency_ping_ms_p2p)
}
inline void CMsgSteamDatagramRouterPingReply::_internal_add_latency_ping_ms_p2p(uint32_t value) {
  _impl_.latency_ping_ms_p2p_.Add(value);
}
inline void CMsgSteamDatagramRouterPingReply::add_latency_ping_ms_p2p(uint32_t value) {
  _internal_add_latency_ping_ms_p2p(value);
  // @@protoc_insertion_point(field_add:CMsgSteamDatagramRouterPingReply.latency_ping_ms_p2p)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
CMsgSteamDatagramRouterPingReply::_internal_latency_ping_ms_p2p() const {
  return _impl_.latency_ping_ms_p2p_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
CMsgSteamDatagramRouterPingReply::latency_ping_ms_p2p() const {
  // @@protoc_insertion_point(field_list:CMsgSteamDatagramRouterPingReply.latency_ping_ms_p2p)
  return _internal_latency_ping_ms_p2p();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
CMsgSteamDatagramRouterPingReply::_internal_mutable_latency_ping_ms_p2p() {
  return &_impl_.latency_ping_ms_p2p_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
CMsgSteamDatagramRouterPingReply::mutable_latency_ping_ms_p2p() {
  // @@protoc_insertion_point(field_mutable_list:CMsgSteamDatagramRouterPingReply.latency_ping_ms_p2p)
  return _internal_mutable_latency_ping_ms_p2p();
}

// optional fixed32 your_public_ip = 4;
inline bool CMsgSteamDatagramRouterPingReply::_internal_has_your_public_ip() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgSteamDatagramRouterPingReply::has_your_public_ip() const {
  return _internal_has_your_public_ip();
}
inline void CMsgSteamDatagramRouterPingReply::clear_your_public_ip() {
  _impl_.your_public_ip_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t CMsgSteamDatagramRouterPingReply::_internal_your_public_ip() const {
  return _impl_.your_public_ip_;
}
inline uint32_t CMsgSteamDatagramRouterPingReply::your_public_ip() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramRouterPingReply.your_public_ip)
  return _internal_your_public_ip();
}
inline void CMsgSteamDatagramRouterPingReply::_internal_set_your_public_ip(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.your_public_ip_ = value;
}
inline void CMsgSteamDatagramRouterPingReply::set_your_public_ip(uint32_t value) {
  _internal_set_your_public_ip(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramRouterPingReply.your_public_ip)
}

// optional fixed32 your_public_port = 11;
inline bool CMsgSteamDatagramRouterPingReply::_internal_has_your_public_port() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool CMsgSteamDatagramRouterPingReply::has_your_public_port() const {
  return _internal_has_your_public_port();
}
inline void CMsgSteamDatagramRouterPingReply::clear_your_public_port() {
  _impl_.your_public_port_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline uint32_t CMsgSteamDatagramRouterPingReply::_internal_your_public_port() const {
  return _impl_.your_public_port_;
}
inline uint32_t CMsgSteamDatagramRouterPingReply::your_public_port() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramRouterPingReply.your_public_port)
  return _internal_your_public_port();
}
inline void CMsgSteamDatagramRouterPingReply::_internal_set_your_public_port(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.your_public_port_ = value;
}
inline void CMsgSteamDatagramRouterPingReply::set_your_public_port(uint32_t value) {
  _internal_set_your_public_port(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramRouterPingReply.your_public_port)
}

// optional fixed32 server_time = 5;
inline bool CMsgSteamDatagramRouterPingReply::_internal_has_server_time() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CMsgSteamDatagramRouterPingReply::has_server_time() const {
  return _internal_has_server_time();
}
inline void CMsgSteamDatagramRouterPingReply::clear_server_time() {
  _impl_.server_time_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline uint32_t CMsgSteamDatagramRouterPingReply::_internal_server_time() const {
  return _impl_.server_time_;
}
inline uint32_t CMsgSteamDatagramRouterPingReply::server_time() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramRouterPingReply.server_time)
  return _internal_server_time();
}
inline void CMsgSteamDatagramRouterPingReply::_internal_set_server_time(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.server_time_ = value;
}
inline void CMsgSteamDatagramRouterPingReply::set_server_time(uint32_t value) {
  _internal_set_server_time(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramRouterPingReply.server_time)
}

// optional fixed64 challenge = 6;
inline bool CMsgSteamDatagramRouterPingReply::_internal_has_challenge() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CMsgSteamDatagramRouterPingReply::has_challenge() const {
  return _internal_has_challenge();
}
inline void CMsgSteamDatagramRouterPingReply::clear_challenge() {
  _impl_.challenge_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint64_t CMsgSteamDatagramRouterPingReply::_internal_challenge() const {
  return _impl_.challenge_;
}
inline uint64_t CMsgSteamDatagramRouterPingReply::challenge() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramRouterPingReply.challenge)
  return _internal_challenge();
}
inline void CMsgSteamDatagramRouterPingReply::_internal_set_challenge(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.challenge_ = value;
}
inline void CMsgSteamDatagramRouterPingReply::set_challenge(uint64_t value) {
  _internal_set_challenge(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramRouterPingReply.challenge)
}

// optional uint32 seconds_until_shutdown = 7;
inline bool CMsgSteamDatagramRouterPingReply::_internal_has_seconds_until_shutdown() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool CMsgSteamDatagramRouterPingReply::has_seconds_until_shutdown() const {
  return _internal_has_seconds_until_shutdown();
}
inline void CMsgSteamDatagramRouterPingReply::clear_seconds_until_shutdown() {
  _impl_.seconds_until_shutdown_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline uint32_t CMsgSteamDatagramRouterPingReply::_internal_seconds_until_shutdown() const {
  return _impl_.seconds_until_shutdown_;
}
inline uint32_t CMsgSteamDatagramRouterPingReply::seconds_until_shutdown() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramRouterPingReply.seconds_until_shutdown)
  return _internal_seconds_until_shutdown();
}
inline void CMsgSteamDatagramRouterPingReply::_internal_set_seconds_until_shutdown(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.seconds_until_shutdown_ = value;
}
inline void CMsgSteamDatagramRouterPingReply::set_seconds_until_shutdown(uint32_t value) {
  _internal_set_seconds_until_shutdown(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramRouterPingReply.seconds_until_shutdown)
}

// optional fixed32 client_cookie = 8;
inline bool CMsgSteamDatagramRouterPingReply::_internal_has_client_cookie() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool CMsgSteamDatagramRouterPingReply::has_client_cookie() const {
  return _internal_has_client_cookie();
}
inline void CMsgSteamDatagramRouterPingReply::clear_client_cookie() {
  _impl_.client_cookie_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline uint32_t CMsgSteamDatagramRouterPingReply::_internal_client_cookie() const {
  return _impl_.client_cookie_;
}
inline uint32_t CMsgSteamDatagramRouterPingReply::client_cookie() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramRouterPingReply.client_cookie)
  return _internal_client_cookie();
}
inline void CMsgSteamDatagramRouterPingReply::_internal_set_client_cookie(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.client_cookie_ = value;
}
inline void CMsgSteamDatagramRouterPingReply::set_client_cookie(uint32_t value) {
  _internal_set_client_cookie(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramRouterPingReply.client_cookie)
}

// optional uint32 recv_tos = 16;
inline bool CMsgSteamDatagramRouterPingReply::_internal_has_recv_tos() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool CMsgSteamDatagramRouterPingReply::has_recv_tos() const {
  return _internal_has_recv_tos();
}
inline void CMsgSteamDatagramRouterPingReply::clear_recv_tos() {
  _impl_.recv_tos_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline uint32_t CMsgSteamDatagramRouterPingReply::_internal_recv_tos() const {
  return _impl_.recv_tos_;
}
inline uint32_t CMsgSteamDatagramRouterPingReply::recv_tos() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramRouterPingReply.recv_tos)
  return _internal_recv_tos();
}
inline void CMsgSteamDatagramRouterPingReply::_internal_set_recv_tos(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000400u;
  _impl_.recv_tos_ = value;
}
inline void CMsgSteamDatagramRouterPingReply::set_recv_tos(uint32_t value) {
  _internal_set_recv_tos(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramRouterPingReply.recv_tos)
}

// optional uint32 echo_sent_tos = 17;
inline bool CMsgSteamDatagramRouterPingReply::_internal_has_echo_sent_tos() const {
  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
  return value;
}
inline bool CMsgSteamDatagramRouterPingReply::has_echo_sent_tos() const {
  return _internal_has_echo_sent_tos();
}
inline void CMsgSteamDatagramRouterPingReply::clear_echo_sent_tos() {
  _impl_.echo_sent_tos_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000800u;
}
inline uint32_t CMsgSteamDatagramRouterPingReply::_internal_echo_sent_tos() const {
  return _impl_.echo_sent_tos_;
}
inline uint32_t CMsgSteamDatagramRouterPingReply::echo_sent_tos() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramRouterPingReply.echo_sent_tos)
  return _internal_echo_sent_tos();
}
inline void CMsgSteamDatagramRouterPingReply::_internal_set_echo_sent_tos(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000800u;
  _impl_.echo_sent_tos_ = value;
}
inline void CMsgSteamDatagramRouterPingReply::set_echo_sent_tos(uint32_t value) {
  _internal_set_echo_sent_tos(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramRouterPingReply.echo_sent_tos)
}

// optional uint32 sent_tos = 18;
inline bool CMsgSteamDatagramRouterPingReply::_internal_has_sent_tos() const {
  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
  return value;
}
inline bool CMsgSteamDatagramRouterPingReply::has_sent_tos() const {
  return _internal_has_sent_tos();
}
inline void CMsgSteamDatagramRouterPingReply::clear_sent_tos() {
  _impl_.sent_tos_ = 0u;
  _impl_._has_bits_[0] &= ~0x00001000u;
}
inline uint32_t CMsgSteamDatagramRouterPingReply::_internal_sent_tos() const {
  return _impl_.sent_tos_;
}
inline uint32_t CMsgSteamDatagramRouterPingReply::sent_tos() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramRouterPingReply.sent_tos)
  return _internal_sent_tos();
}
inline void CMsgSteamDatagramRouterPingReply::_internal_set_sent_tos(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00001000u;
  _impl_.sent_tos_ = value;
}
inline void CMsgSteamDatagramRouterPingReply::set_sent_tos(uint32_t value) {
  _internal_set_sent_tos(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramRouterPingReply.sent_tos)
}

// optional uint32 echo_request_reply_tos = 19;
inline bool CMsgSteamDatagramRouterPingReply::_internal_has_echo_request_reply_tos() const {
  bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0;
  return value;
}
inline bool CMsgSteamDatagramRouterPingReply::has_echo_request_reply_tos() const {
  return _internal_has_echo_request_reply_tos();
}
inline void CMsgSteamDatagramRouterPingReply::clear_echo_request_reply_tos() {
  _impl_.echo_request_reply_tos_ = 0u;
  _impl_._has_bits_[0] &= ~0x00002000u;
}
inline uint32_t CMsgSteamDatagramRouterPingReply::_internal_echo_request_reply_tos() const {
  return _impl_.echo_request_reply_tos_;
}
inline uint32_t CMsgSteamDatagramRouterPingReply::echo_request_reply_tos() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramRouterPingReply.echo_request_reply_tos)
  return _internal_echo_request_reply_tos();
}
inline void CMsgSteamDatagramRouterPingReply::_internal_set_echo_request_reply_tos(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00002000u;
  _impl_.echo_request_reply_tos_ = value;
}
inline void CMsgSteamDatagramRouterPingReply::set_echo_request_reply_tos(uint32_t value) {
  _internal_set_echo_request_reply_tos(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramRouterPingReply.echo_request_reply_tos)
}

// optional uint32 scoring_penalty_relay_cluster = 9;
inline bool CMsgSteamDatagramRouterPingReply::_internal_has_scoring_penalty_relay_cluster() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool CMsgSteamDatagramRouterPingReply::has_scoring_penalty_relay_cluster() const {
  return _internal_has_scoring_penalty_relay_cluster();
}
inline void CMsgSteamDatagramRouterPingReply::clear_scoring_penalty_relay_cluster() {
  _impl_.scoring_penalty_relay_cluster_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline uint32_t CMsgSteamDatagramRouterPingReply::_internal_scoring_penalty_relay_cluster() const {
  return _impl_.scoring_penalty_relay_cluster_;
}
inline uint32_t CMsgSteamDatagramRouterPingReply::scoring_penalty_relay_cluster() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramRouterPingReply.scoring_penalty_relay_cluster)
  return _internal_scoring_penalty_relay_cluster();
}
inline void CMsgSteamDatagramRouterPingReply::_internal_set_scoring_penalty_relay_cluster(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.scoring_penalty_relay_cluster_ = value;
}
inline void CMsgSteamDatagramRouterPingReply::set_scoring_penalty_relay_cluster(uint32_t value) {
  _internal_set_scoring_penalty_relay_cluster(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramRouterPingReply.scoring_penalty_relay_cluster)
}

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

// repeated .CMsgSteamDatagramRouterPingReply.RouteException route_exceptions = 10;
inline int CMsgSteamDatagramRouterPingReply::_internal_route_exceptions_size() const {
  return _impl_.route_exceptions_.size();
}
inline int CMsgSteamDatagramRouterPingReply::route_exceptions_size() const {
  return _internal_route_exceptions_size();
}
inline void CMsgSteamDatagramRouterPingReply::clear_route_exceptions() {
  _impl_.route_exceptions_.Clear();
}
inline ::CMsgSteamDatagramRouterPingReply_RouteException* CMsgSteamDatagramRouterPingReply::mutable_route_exceptions(int index) {
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramRouterPingReply.route_exceptions)
  return _impl_.route_exceptions_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgSteamDatagramRouterPingReply_RouteException >*
CMsgSteamDatagramRouterPingReply::mutable_route_exceptions() {
  // @@protoc_insertion_point(field_mutable_list:CMsgSteamDatagramRouterPingReply.route_exceptions)
  return &_impl_.route_exceptions_;
}
inline const ::CMsgSteamDatagramRouterPingReply_RouteException& CMsgSteamDatagramRouterPingReply::_internal_route_exceptions(int index) const {
  return _impl_.route_exceptions_.Get(index);
}
inline const ::CMsgSteamDatagramRouterPingReply_RouteException& CMsgSteamDatagramRouterPingReply::route_exceptions(int index) const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramRouterPingReply.route_exceptions)
  return _internal_route_exceptions(index);
}
inline ::CMsgSteamDatagramRouterPingReply_RouteException* CMsgSteamDatagramRouterPingReply::_internal_add_route_exceptions() {
  return _impl_.route_exceptions_.Add();
}
inline ::CMsgSteamDatagramRouterPingReply_RouteException* CMsgSteamDatagramRouterPingReply::add_route_exceptions() {
  ::CMsgSteamDatagramRouterPingReply_RouteException* _add = _internal_add_route_exceptions();
  // @@protoc_insertion_point(field_add:CMsgSteamDatagramRouterPingReply.route_exceptions)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgSteamDatagramRouterPingReply_RouteException >&
CMsgSteamDatagramRouterPingReply::route_exceptions() const {
  // @@protoc_insertion_point(field_list:CMsgSteamDatagramRouterPingReply.route_exceptions)
  return _impl_.route_exceptions_;
}

// repeated .CMsgSteamDatagramRouterPingReply.AltAddress alt_addresses = 13;
inline int CMsgSteamDatagramRouterPingReply::_internal_alt_addresses_size() const {
  return _impl_.alt_addresses_.size();
}
inline int CMsgSteamDatagramRouterPingReply::alt_addresses_size() const {
  return _internal_alt_addresses_size();
}
inline void CMsgSteamDatagramRouterPingReply::clear_alt_addresses() {
  _impl_.alt_addresses_.Clear();
}
inline ::CMsgSteamDatagramRouterPingReply_AltAddress* CMsgSteamDatagramRouterPingReply::mutable_alt_addresses(int index) {
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramRouterPingReply.alt_addresses)
  return _impl_.alt_addresses_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgSteamDatagramRouterPingReply_AltAddress >*
CMsgSteamDatagramRouterPingReply::mutable_alt_addresses() {
  // @@protoc_insertion_point(field_mutable_list:CMsgSteamDatagramRouterPingReply.alt_addresses)
  return &_impl_.alt_addresses_;
}
inline const ::CMsgSteamDatagramRouterPingReply_AltAddress& CMsgSteamDatagramRouterPingReply::_internal_alt_addresses(int index) const {
  return _impl_.alt_addresses_.Get(index);
}
inline const ::CMsgSteamDatagramRouterPingReply_AltAddress& CMsgSteamDatagramRouterPingReply::alt_addresses(int index) const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramRouterPingReply.alt_addresses)
  return _internal_alt_addresses(index);
}
inline ::CMsgSteamDatagramRouterPingReply_AltAddress* CMsgSteamDatagramRouterPingReply::_internal_add_alt_addresses() {
  return _impl_.alt_addresses_.Add();
}
inline ::CMsgSteamDatagramRouterPingReply_AltAddress* CMsgSteamDatagramRouterPingReply::add_alt_addresses() {
  ::CMsgSteamDatagramRouterPingReply_AltAddress* _add = _internal_add_alt_addresses();
  // @@protoc_insertion_point(field_add:CMsgSteamDatagramRouterPingReply.alt_addresses)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgSteamDatagramRouterPingReply_AltAddress >&
CMsgSteamDatagramRouterPingReply::alt_addresses() const {
  // @@protoc_insertion_point(field_list:CMsgSteamDatagramRouterPingReply.alt_addresses)
  return _impl_.alt_addresses_;
}

// optional bytes dummy_pad = 99;
inline bool CMsgSteamDatagramRouterPingReply::_internal_has_dummy_pad() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgSteamDatagramRouterPingReply::has_dummy_pad() const {
  return _internal_has_dummy_pad();
}
inline void CMsgSteamDatagramRouterPingReply::clear_dummy_pad() {
  _impl_.dummy_pad_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CMsgSteamDatagramRouterPingReply::dummy_pad() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramRouterPingReply.dummy_pad)
  return _internal_dummy_pad();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgSteamDatagramRouterPingReply::set_dummy_pad(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.dummy_pad_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramRouterPingReply.dummy_pad)
}
inline std::string* CMsgSteamDatagramRouterPingReply::mutable_dummy_pad() {
  std::string* _s = _internal_mutable_dummy_pad();
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramRouterPingReply.dummy_pad)
  return _s;
}
inline const std::string& CMsgSteamDatagramRouterPingReply::_internal_dummy_pad() const {
  return _impl_.dummy_pad_.Get();
}
inline void CMsgSteamDatagramRouterPingReply::_internal_set_dummy_pad(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.dummy_pad_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramRouterPingReply::_internal_mutable_dummy_pad() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.dummy_pad_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramRouterPingReply::release_dummy_pad() {
  // @@protoc_insertion_point(field_release:CMsgSteamDatagramRouterPingReply.dummy_pad)
  if (!_internal_has_dummy_pad()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.dummy_pad_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.dummy_pad_.IsDefault()) {
    _impl_.dummy_pad_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgSteamDatagramRouterPingReply::set_allocated_dummy_pad(std::string* dummy_pad) {
  if (dummy_pad != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.dummy_pad_.SetAllocated(dummy_pad, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.dummy_pad_.IsDefault()) {
    _impl_.dummy_pad_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamDatagramRouterPingReply.dummy_pad)
}

// optional uint64 dummy_varint = 100;
inline bool CMsgSteamDatagramRouterPingReply::_internal_has_dummy_varint() const {
  bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0;
  return value;
}
inline bool CMsgSteamDatagramRouterPingReply::has_dummy_varint() const {
  return _internal_has_dummy_varint();
}
inline void CMsgSteamDatagramRouterPingReply::clear_dummy_varint() {
  _impl_.dummy_varint_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00004000u;
}
inline uint64_t CMsgSteamDatagramRouterPingReply::_internal_dummy_varint() const {
  return _impl_.dummy_varint_;
}
inline uint64_t CMsgSteamDatagramRouterPingReply::dummy_varint() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramRouterPingReply.dummy_varint)
  return _internal_dummy_varint();
}
inline void CMsgSteamDatagramRouterPingReply::_internal_set_dummy_varint(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00004000u;
  _impl_.dummy_varint_ = value;
}
inline void CMsgSteamDatagramRouterPingReply::set_dummy_varint(uint64_t value) {
  _internal_set_dummy_varint(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramRouterPingReply.dummy_varint)
}

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

// CMsgSteamDatagramGameserverPingRequestBody

// optional fixed32 relay_popid = 1;
inline bool CMsgSteamDatagramGameserverPingRequestBody::_internal_has_relay_popid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgSteamDatagramGameserverPingRequestBody::has_relay_popid() const {
  return _internal_has_relay_popid();
}
inline void CMsgSteamDatagramGameserverPingRequestBody::clear_relay_popid() {
  _impl_.relay_popid_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t CMsgSteamDatagramGameserverPingRequestBody::_internal_relay_popid() const {
  return _impl_.relay_popid_;
}
inline uint32_t CMsgSteamDatagramGameserverPingRequestBody::relay_popid() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramGameserverPingRequestBody.relay_popid)
  return _internal_relay_popid();
}
inline void CMsgSteamDatagramGameserverPingRequestBody::_internal_set_relay_popid(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.relay_popid_ = value;
}
inline void CMsgSteamDatagramGameserverPingRequestBody::set_relay_popid(uint32_t value) {
  _internal_set_relay_popid(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramGameserverPingRequestBody.relay_popid)
}

// optional .CMsgSteamNetworkingIPAddress your_public_ip = 2;
inline bool CMsgSteamDatagramGameserverPingRequestBody::_internal_has_your_public_ip() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.your_public_ip_ != nullptr);
  return value;
}
inline bool CMsgSteamDatagramGameserverPingRequestBody::has_your_public_ip() const {
  return _internal_has_your_public_ip();
}
inline void CMsgSteamDatagramGameserverPingRequestBody::clear_your_public_ip() {
  if (_impl_.your_public_ip_ != nullptr) _impl_.your_public_ip_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::CMsgSteamNetworkingIPAddress& CMsgSteamDatagramGameserverPingRequestBody::_internal_your_public_ip() const {
  const ::CMsgSteamNetworkingIPAddress* p = _impl_.your_public_ip_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgSteamNetworkingIPAddress&>(
      ::_CMsgSteamNetworkingIPAddress_default_instance_);
}
inline const ::CMsgSteamNetworkingIPAddress& CMsgSteamDatagramGameserverPingRequestBody::your_public_ip() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramGameserverPingRequestBody.your_public_ip)
  return _internal_your_public_ip();
}
inline void CMsgSteamDatagramGameserverPingRequestBody::unsafe_arena_set_allocated_your_public_ip(
    ::CMsgSteamNetworkingIPAddress* your_public_ip) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.your_public_ip_);
  }
  _impl_.your_public_ip_ = your_public_ip;
  if (your_public_ip) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgSteamDatagramGameserverPingRequestBody.your_public_ip)
}
inline ::CMsgSteamNetworkingIPAddress* CMsgSteamDatagramGameserverPingRequestBody::release_your_public_ip() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgSteamNetworkingIPAddress* temp = _impl_.your_public_ip_;
  _impl_.your_public_ip_ = 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 ::CMsgSteamNetworkingIPAddress* CMsgSteamDatagramGameserverPingRequestBody::unsafe_arena_release_your_public_ip() {
  // @@protoc_insertion_point(field_release:CMsgSteamDatagramGameserverPingRequestBody.your_public_ip)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgSteamNetworkingIPAddress* temp = _impl_.your_public_ip_;
  _impl_.your_public_ip_ = nullptr;
  return temp;
}
inline ::CMsgSteamNetworkingIPAddress* CMsgSteamDatagramGameserverPingRequestBody::_internal_mutable_your_public_ip() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.your_public_ip_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgSteamNetworkingIPAddress>(GetArenaForAllocation());
    _impl_.your_public_ip_ = p;
  }
  return _impl_.your_public_ip_;
}
inline ::CMsgSteamNetworkingIPAddress* CMsgSteamDatagramGameserverPingRequestBody::mutable_your_public_ip() {
  ::CMsgSteamNetworkingIPAddress* _msg = _internal_mutable_your_public_ip();
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramGameserverPingRequestBody.your_public_ip)
  return _msg;
}
inline void CMsgSteamDatagramGameserverPingRequestBody::set_allocated_your_public_ip(::CMsgSteamNetworkingIPAddress* your_public_ip) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.your_public_ip_;
  }
  if (your_public_ip) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(your_public_ip);
    if (message_arena != submessage_arena) {
      your_public_ip = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, your_public_ip, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.your_public_ip_ = your_public_ip;
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamDatagramGameserverPingRequestBody.your_public_ip)
}

// optional uint32 your_public_port = 3;
inline bool CMsgSteamDatagramGameserverPingRequestBody::_internal_has_your_public_port() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CMsgSteamDatagramGameserverPingRequestBody::has_your_public_port() const {
  return _internal_has_your_public_port();
}
inline void CMsgSteamDatagramGameserverPingRequestBody::clear_your_public_port() {
  _impl_.your_public_port_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t CMsgSteamDatagramGameserverPingRequestBody::_internal_your_public_port() const {
  return _impl_.your_public_port_;
}
inline uint32_t CMsgSteamDatagramGameserverPingRequestBody::your_public_port() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramGameserverPingRequestBody.your_public_port)
  return _internal_your_public_port();
}
inline void CMsgSteamDatagramGameserverPingRequestBody::_internal_set_your_public_port(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.your_public_port_ = value;
}
inline void CMsgSteamDatagramGameserverPingRequestBody::set_your_public_port(uint32_t value) {
  _internal_set_your_public_port(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramGameserverPingRequestBody.your_public_port)
}

// optional uint64 relay_unix_time = 4;
inline bool CMsgSteamDatagramGameserverPingRequestBody::_internal_has_relay_unix_time() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CMsgSteamDatagramGameserverPingRequestBody::has_relay_unix_time() const {
  return _internal_has_relay_unix_time();
}
inline void CMsgSteamDatagramGameserverPingRequestBody::clear_relay_unix_time() {
  _impl_.relay_unix_time_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline uint64_t CMsgSteamDatagramGameserverPingRequestBody::_internal_relay_unix_time() const {
  return _impl_.relay_unix_time_;
}
inline uint64_t CMsgSteamDatagramGameserverPingRequestBody::relay_unix_time() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramGameserverPingRequestBody.relay_unix_time)
  return _internal_relay_unix_time();
}
inline void CMsgSteamDatagramGameserverPingRequestBody::_internal_set_relay_unix_time(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.relay_unix_time_ = value;
}
inline void CMsgSteamDatagramGameserverPingRequestBody::set_relay_unix_time(uint64_t value) {
  _internal_set_relay_unix_time(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramGameserverPingRequestBody.relay_unix_time)
}

// optional fixed64 routing_secret = 5;
inline bool CMsgSteamDatagramGameserverPingRequestBody::_internal_has_routing_secret() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool CMsgSteamDatagramGameserverPingRequestBody::has_routing_secret() const {
  return _internal_has_routing_secret();
}
inline void CMsgSteamDatagramGameserverPingRequestBody::clear_routing_secret() {
  _impl_.routing_secret_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline uint64_t CMsgSteamDatagramGameserverPingRequestBody::_internal_routing_secret() const {
  return _impl_.routing_secret_;
}
inline uint64_t CMsgSteamDatagramGameserverPingRequestBody::routing_secret() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramGameserverPingRequestBody.routing_secret)
  return _internal_routing_secret();
}
inline void CMsgSteamDatagramGameserverPingRequestBody::_internal_set_routing_secret(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.routing_secret_ = value;
}
inline void CMsgSteamDatagramGameserverPingRequestBody::set_routing_secret(uint64_t value) {
  _internal_set_routing_secret(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramGameserverPingRequestBody.routing_secret)
}

// repeated .CMsgSteamNetworkingIPAddress my_ips = 6;
inline int CMsgSteamDatagramGameserverPingRequestBody::_internal_my_ips_size() const {
  return _impl_.my_ips_.size();
}
inline int CMsgSteamDatagramGameserverPingRequestBody::my_ips_size() const {
  return _internal_my_ips_size();
}
inline void CMsgSteamDatagramGameserverPingRequestBody::clear_my_ips() {
  _impl_.my_ips_.Clear();
}
inline ::CMsgSteamNetworkingIPAddress* CMsgSteamDatagramGameserverPingRequestBody::mutable_my_ips(int index) {
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramGameserverPingRequestBody.my_ips)
  return _impl_.my_ips_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgSteamNetworkingIPAddress >*
CMsgSteamDatagramGameserverPingRequestBody::mutable_my_ips() {
  // @@protoc_insertion_point(field_mutable_list:CMsgSteamDatagramGameserverPingRequestBody.my_ips)
  return &_impl_.my_ips_;
}
inline const ::CMsgSteamNetworkingIPAddress& CMsgSteamDatagramGameserverPingRequestBody::_internal_my_ips(int index) const {
  return _impl_.my_ips_.Get(index);
}
inline const ::CMsgSteamNetworkingIPAddress& CMsgSteamDatagramGameserverPingRequestBody::my_ips(int index) const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramGameserverPingRequestBody.my_ips)
  return _internal_my_ips(index);
}
inline ::CMsgSteamNetworkingIPAddress* CMsgSteamDatagramGameserverPingRequestBody::_internal_add_my_ips() {
  return _impl_.my_ips_.Add();
}
inline ::CMsgSteamNetworkingIPAddress* CMsgSteamDatagramGameserverPingRequestBody::add_my_ips() {
  ::CMsgSteamNetworkingIPAddress* _add = _internal_add_my_ips();
  // @@protoc_insertion_point(field_add:CMsgSteamDatagramGameserverPingRequestBody.my_ips)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgSteamNetworkingIPAddress >&
CMsgSteamDatagramGameserverPingRequestBody::my_ips() const {
  // @@protoc_insertion_point(field_list:CMsgSteamDatagramGameserverPingRequestBody.my_ips)
  return _impl_.my_ips_;
}

// optional bytes echo = 8;
inline bool CMsgSteamDatagramGameserverPingRequestBody::_internal_has_echo() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgSteamDatagramGameserverPingRequestBody::has_echo() const {
  return _internal_has_echo();
}
inline void CMsgSteamDatagramGameserverPingRequestBody::clear_echo() {
  _impl_.echo_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CMsgSteamDatagramGameserverPingRequestBody::echo() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramGameserverPingRequestBody.echo)
  return _internal_echo();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgSteamDatagramGameserverPingRequestBody::set_echo(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.echo_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramGameserverPingRequestBody.echo)
}
inline std::string* CMsgSteamDatagramGameserverPingRequestBody::mutable_echo() {
  std::string* _s = _internal_mutable_echo();
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramGameserverPingRequestBody.echo)
  return _s;
}
inline const std::string& CMsgSteamDatagramGameserverPingRequestBody::_internal_echo() const {
  return _impl_.echo_.Get();
}
inline void CMsgSteamDatagramGameserverPingRequestBody::_internal_set_echo(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.echo_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramGameserverPingRequestBody::_internal_mutable_echo() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.echo_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramGameserverPingRequestBody::release_echo() {
  // @@protoc_insertion_point(field_release:CMsgSteamDatagramGameserverPingRequestBody.echo)
  if (!_internal_has_echo()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.echo_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.echo_.IsDefault()) {
    _impl_.echo_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgSteamDatagramGameserverPingRequestBody::set_allocated_echo(std::string* echo) {
  if (echo != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.echo_.SetAllocated(echo, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.echo_.IsDefault()) {
    _impl_.echo_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamDatagramGameserverPingRequestBody.echo)
}

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

// CMsgSteamDatagramGameserverPingRequestEnvelope

// optional .CMsgSteamDatagramCertificateSigned cert = 6;
inline bool CMsgSteamDatagramGameserverPingRequestEnvelope::_internal_has_cert() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.cert_ != nullptr);
  return value;
}
inline bool CMsgSteamDatagramGameserverPingRequestEnvelope::has_cert() const {
  return _internal_has_cert();
}
inline const ::CMsgSteamDatagramCertificateSigned& CMsgSteamDatagramGameserverPingRequestEnvelope::_internal_cert() const {
  const ::CMsgSteamDatagramCertificateSigned* p = _impl_.cert_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgSteamDatagramCertificateSigned&>(
      ::_CMsgSteamDatagramCertificateSigned_default_instance_);
}
inline const ::CMsgSteamDatagramCertificateSigned& CMsgSteamDatagramGameserverPingRequestEnvelope::cert() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramGameserverPingRequestEnvelope.cert)
  return _internal_cert();
}
inline void CMsgSteamDatagramGameserverPingRequestEnvelope::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] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgSteamDatagramGameserverPingRequestEnvelope.cert)
}
inline ::CMsgSteamDatagramCertificateSigned* CMsgSteamDatagramGameserverPingRequestEnvelope::release_cert() {
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::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* CMsgSteamDatagramGameserverPingRequestEnvelope::unsafe_arena_release_cert() {
  // @@protoc_insertion_point(field_release:CMsgSteamDatagramGameserverPingRequestEnvelope.cert)
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::CMsgSteamDatagramCertificateSigned* temp = _impl_.cert_;
  _impl_.cert_ = nullptr;
  return temp;
}
inline ::CMsgSteamDatagramCertificateSigned* CMsgSteamDatagramGameserverPingRequestEnvelope::_internal_mutable_cert() {
  _impl_._has_bits_[0] |= 0x00000008u;
  if (_impl_.cert_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgSteamDatagramCertificateSigned>(GetArenaForAllocation());
    _impl_.cert_ = p;
  }
  return _impl_.cert_;
}
inline ::CMsgSteamDatagramCertificateSigned* CMsgSteamDatagramGameserverPingRequestEnvelope::mutable_cert() {
  ::CMsgSteamDatagramCertificateSigned* _msg = _internal_mutable_cert();
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramGameserverPingRequestEnvelope.cert)
  return _msg;
}
inline void CMsgSteamDatagramGameserverPingRequestEnvelope::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] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.cert_ = cert;
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamDatagramGameserverPingRequestEnvelope.cert)
}

// optional bytes signed_data = 7;
inline bool CMsgSteamDatagramGameserverPingRequestEnvelope::_internal_has_signed_data() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgSteamDatagramGameserverPingRequestEnvelope::has_signed_data() const {
  return _internal_has_signed_data();
}
inline void CMsgSteamDatagramGameserverPingRequestEnvelope::clear_signed_data() {
  _impl_.signed_data_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CMsgSteamDatagramGameserverPingRequestEnvelope::signed_data() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramGameserverPingRequestEnvelope.signed_data)
  return _internal_signed_data();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgSteamDatagramGameserverPingRequestEnvelope::set_signed_data(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.signed_data_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramGameserverPingRequestEnvelope.signed_data)
}
inline std::string* CMsgSteamDatagramGameserverPingRequestEnvelope::mutable_signed_data() {
  std::string* _s = _internal_mutable_signed_data();
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramGameserverPingRequestEnvelope.signed_data)
  return _s;
}
inline const std::string& CMsgSteamDatagramGameserverPingRequestEnvelope::_internal_signed_data() const {
  return _impl_.signed_data_.Get();
}
inline void CMsgSteamDatagramGameserverPingRequestEnvelope::_internal_set_signed_data(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.signed_data_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramGameserverPingRequestEnvelope::_internal_mutable_signed_data() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.signed_data_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramGameserverPingRequestEnvelope::release_signed_data() {
  // @@protoc_insertion_point(field_release:CMsgSteamDatagramGameserverPingRequestEnvelope.signed_data)
  if (!_internal_has_signed_data()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.signed_data_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.signed_data_.IsDefault()) {
    _impl_.signed_data_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgSteamDatagramGameserverPingRequestEnvelope::set_allocated_signed_data(std::string* signed_data) {
  if (signed_data != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.signed_data_.SetAllocated(signed_data, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.signed_data_.IsDefault()) {
    _impl_.signed_data_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamDatagramGameserverPingRequestEnvelope.signed_data)
}

// optional bytes signature = 8;
inline bool CMsgSteamDatagramGameserverPingRequestEnvelope::_internal_has_signature() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgSteamDatagramGameserverPingRequestEnvelope::has_signature() const {
  return _internal_has_signature();
}
inline void CMsgSteamDatagramGameserverPingRequestEnvelope::clear_signature() {
  _impl_.signature_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& CMsgSteamDatagramGameserverPingRequestEnvelope::signature() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramGameserverPingRequestEnvelope.signature)
  return _internal_signature();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgSteamDatagramGameserverPingRequestEnvelope::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:CMsgSteamDatagramGameserverPingRequestEnvelope.signature)
}
inline std::string* CMsgSteamDatagramGameserverPingRequestEnvelope::mutable_signature() {
  std::string* _s = _internal_mutable_signature();
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramGameserverPingRequestEnvelope.signature)
  return _s;
}
inline const std::string& CMsgSteamDatagramGameserverPingRequestEnvelope::_internal_signature() const {
  return _impl_.signature_.Get();
}
inline void CMsgSteamDatagramGameserverPingRequestEnvelope::_internal_set_signature(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.signature_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramGameserverPingRequestEnvelope::_internal_mutable_signature() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.signature_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramGameserverPingRequestEnvelope::release_signature() {
  // @@protoc_insertion_point(field_release:CMsgSteamDatagramGameserverPingRequestEnvelope.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 CMsgSteamDatagramGameserverPingRequestEnvelope::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:CMsgSteamDatagramGameserverPingRequestEnvelope.signature)
}

// optional fixed32 legacy_your_public_ip = 1;
inline bool CMsgSteamDatagramGameserverPingRequestEnvelope::_internal_has_legacy_your_public_ip() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CMsgSteamDatagramGameserverPingRequestEnvelope::has_legacy_your_public_ip() const {
  return _internal_has_legacy_your_public_ip();
}
inline void CMsgSteamDatagramGameserverPingRequestEnvelope::clear_legacy_your_public_ip() {
  _impl_.legacy_your_public_ip_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline uint32_t CMsgSteamDatagramGameserverPingRequestEnvelope::_internal_legacy_your_public_ip() const {
  return _impl_.legacy_your_public_ip_;
}
inline uint32_t CMsgSteamDatagramGameserverPingRequestEnvelope::legacy_your_public_ip() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramGameserverPingRequestEnvelope.legacy_your_public_ip)
  return _internal_legacy_your_public_ip();
}
inline void CMsgSteamDatagramGameserverPingRequestEnvelope::_internal_set_legacy_your_public_ip(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.legacy_your_public_ip_ = value;
}
inline void CMsgSteamDatagramGameserverPingRequestEnvelope::set_legacy_your_public_ip(uint32_t value) {
  _internal_set_legacy_your_public_ip(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramGameserverPingRequestEnvelope.legacy_your_public_ip)
}

// optional fixed32 legacy_your_public_port = 5;
inline bool CMsgSteamDatagramGameserverPingRequestEnvelope::_internal_has_legacy_your_public_port() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool CMsgSteamDatagramGameserverPingRequestEnvelope::has_legacy_your_public_port() const {
  return _internal_has_legacy_your_public_port();
}
inline void CMsgSteamDatagramGameserverPingRequestEnvelope::clear_legacy_your_public_port() {
  _impl_.legacy_your_public_port_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline uint32_t CMsgSteamDatagramGameserverPingRequestEnvelope::_internal_legacy_your_public_port() const {
  return _impl_.legacy_your_public_port_;
}
inline uint32_t CMsgSteamDatagramGameserverPingRequestEnvelope::legacy_your_public_port() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramGameserverPingRequestEnvelope.legacy_your_public_port)
  return _internal_legacy_your_public_port();
}
inline void CMsgSteamDatagramGameserverPingRequestEnvelope::_internal_set_legacy_your_public_port(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.legacy_your_public_port_ = value;
}
inline void CMsgSteamDatagramGameserverPingRequestEnvelope::set_legacy_your_public_port(uint32_t value) {
  _internal_set_legacy_your_public_port(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramGameserverPingRequestEnvelope.legacy_your_public_port)
}

// optional fixed32 legacy_relay_unix_time = 2;
inline bool CMsgSteamDatagramGameserverPingRequestEnvelope::_internal_has_legacy_relay_unix_time() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool CMsgSteamDatagramGameserverPingRequestEnvelope::has_legacy_relay_unix_time() const {
  return _internal_has_legacy_relay_unix_time();
}
inline void CMsgSteamDatagramGameserverPingRequestEnvelope::clear_legacy_relay_unix_time() {
  _impl_.legacy_relay_unix_time_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline uint32_t CMsgSteamDatagramGameserverPingRequestEnvelope::_internal_legacy_relay_unix_time() const {
  return _impl_.legacy_relay_unix_time_;
}
inline uint32_t CMsgSteamDatagramGameserverPingRequestEnvelope::legacy_relay_unix_time() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramGameserverPingRequestEnvelope.legacy_relay_unix_time)
  return _internal_legacy_relay_unix_time();
}
inline void CMsgSteamDatagramGameserverPingRequestEnvelope::_internal_set_legacy_relay_unix_time(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.legacy_relay_unix_time_ = value;
}
inline void CMsgSteamDatagramGameserverPingRequestEnvelope::set_legacy_relay_unix_time(uint32_t value) {
  _internal_set_legacy_relay_unix_time(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramGameserverPingRequestEnvelope.legacy_relay_unix_time)
}

// optional fixed64 legacy_challenge = 3;
inline bool CMsgSteamDatagramGameserverPingRequestEnvelope::_internal_has_legacy_challenge() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool CMsgSteamDatagramGameserverPingRequestEnvelope::has_legacy_challenge() const {
  return _internal_has_legacy_challenge();
}
inline void CMsgSteamDatagramGameserverPingRequestEnvelope::clear_legacy_challenge() {
  _impl_.legacy_challenge_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline uint64_t CMsgSteamDatagramGameserverPingRequestEnvelope::_internal_legacy_challenge() const {
  return _impl_.legacy_challenge_;
}
inline uint64_t CMsgSteamDatagramGameserverPingRequestEnvelope::legacy_challenge() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramGameserverPingRequestEnvelope.legacy_challenge)
  return _internal_legacy_challenge();
}
inline void CMsgSteamDatagramGameserverPingRequestEnvelope::_internal_set_legacy_challenge(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.legacy_challenge_ = value;
}
inline void CMsgSteamDatagramGameserverPingRequestEnvelope::set_legacy_challenge(uint64_t value) {
  _internal_set_legacy_challenge(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramGameserverPingRequestEnvelope.legacy_challenge)
}

// optional fixed32 legacy_router_timestamp = 4;
inline bool CMsgSteamDatagramGameserverPingRequestEnvelope::_internal_has_legacy_router_timestamp() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool CMsgSteamDatagramGameserverPingRequestEnvelope::has_legacy_router_timestamp() const {
  return _internal_has_legacy_router_timestamp();
}
inline void CMsgSteamDatagramGameserverPingRequestEnvelope::clear_legacy_router_timestamp() {
  _impl_.legacy_router_timestamp_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline uint32_t CMsgSteamDatagramGameserverPingRequestEnvelope::_internal_legacy_router_timestamp() const {
  return _impl_.legacy_router_timestamp_;
}
inline uint32_t CMsgSteamDatagramGameserverPingRequestEnvelope::legacy_router_timestamp() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramGameserverPingRequestEnvelope.legacy_router_timestamp)
  return _internal_legacy_router_timestamp();
}
inline void CMsgSteamDatagramGameserverPingRequestEnvelope::_internal_set_legacy_router_timestamp(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.legacy_router_timestamp_ = value;
}
inline void CMsgSteamDatagramGameserverPingRequestEnvelope::set_legacy_router_timestamp(uint32_t value) {
  _internal_set_legacy_router_timestamp(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramGameserverPingRequestEnvelope.legacy_router_timestamp)
}

// optional bytes dummy_pad = 1023;
inline bool CMsgSteamDatagramGameserverPingRequestEnvelope::_internal_has_dummy_pad() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgSteamDatagramGameserverPingRequestEnvelope::has_dummy_pad() const {
  return _internal_has_dummy_pad();
}
inline void CMsgSteamDatagramGameserverPingRequestEnvelope::clear_dummy_pad() {
  _impl_.dummy_pad_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& CMsgSteamDatagramGameserverPingRequestEnvelope::dummy_pad() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramGameserverPingRequestEnvelope.dummy_pad)
  return _internal_dummy_pad();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgSteamDatagramGameserverPingRequestEnvelope::set_dummy_pad(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.dummy_pad_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramGameserverPingRequestEnvelope.dummy_pad)
}
inline std::string* CMsgSteamDatagramGameserverPingRequestEnvelope::mutable_dummy_pad() {
  std::string* _s = _internal_mutable_dummy_pad();
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramGameserverPingRequestEnvelope.dummy_pad)
  return _s;
}
inline const std::string& CMsgSteamDatagramGameserverPingRequestEnvelope::_internal_dummy_pad() const {
  return _impl_.dummy_pad_.Get();
}
inline void CMsgSteamDatagramGameserverPingRequestEnvelope::_internal_set_dummy_pad(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.dummy_pad_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramGameserverPingRequestEnvelope::_internal_mutable_dummy_pad() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.dummy_pad_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramGameserverPingRequestEnvelope::release_dummy_pad() {
  // @@protoc_insertion_point(field_release:CMsgSteamDatagramGameserverPingRequestEnvelope.dummy_pad)
  if (!_internal_has_dummy_pad()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* p = _impl_.dummy_pad_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.dummy_pad_.IsDefault()) {
    _impl_.dummy_pad_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgSteamDatagramGameserverPingRequestEnvelope::set_allocated_dummy_pad(std::string* dummy_pad) {
  if (dummy_pad != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.dummy_pad_.SetAllocated(dummy_pad, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.dummy_pad_.IsDefault()) {
    _impl_.dummy_pad_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamDatagramGameserverPingRequestEnvelope.dummy_pad)
}

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

// CMsgSteamDatagramGameserverPingReplyData

// optional fixed32 echo_relay_unix_time = 2;
inline bool CMsgSteamDatagramGameserverPingReplyData::_internal_has_echo_relay_unix_time() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CMsgSteamDatagramGameserverPingReplyData::has_echo_relay_unix_time() const {
  return _internal_has_echo_relay_unix_time();
}
inline void CMsgSteamDatagramGameserverPingReplyData::clear_echo_relay_unix_time() {
  _impl_.echo_relay_unix_time_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline uint32_t CMsgSteamDatagramGameserverPingReplyData::_internal_echo_relay_unix_time() const {
  return _impl_.echo_relay_unix_time_;
}
inline uint32_t CMsgSteamDatagramGameserverPingReplyData::echo_relay_unix_time() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramGameserverPingReplyData.echo_relay_unix_time)
  return _internal_echo_relay_unix_time();
}
inline void CMsgSteamDatagramGameserverPingReplyData::_internal_set_echo_relay_unix_time(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.echo_relay_unix_time_ = value;
}
inline void CMsgSteamDatagramGameserverPingReplyData::set_echo_relay_unix_time(uint32_t value) {
  _internal_set_echo_relay_unix_time(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramGameserverPingReplyData.echo_relay_unix_time)
}

// optional bytes echo = 8;
inline bool CMsgSteamDatagramGameserverPingReplyData::_internal_has_echo() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgSteamDatagramGameserverPingReplyData::has_echo() const {
  return _internal_has_echo();
}
inline void CMsgSteamDatagramGameserverPingReplyData::clear_echo() {
  _impl_.echo_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CMsgSteamDatagramGameserverPingReplyData::echo() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramGameserverPingReplyData.echo)
  return _internal_echo();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgSteamDatagramGameserverPingReplyData::set_echo(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.echo_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramGameserverPingReplyData.echo)
}
inline std::string* CMsgSteamDatagramGameserverPingReplyData::mutable_echo() {
  std::string* _s = _internal_mutable_echo();
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramGameserverPingReplyData.echo)
  return _s;
}
inline const std::string& CMsgSteamDatagramGameserverPingReplyData::_internal_echo() const {
  return _impl_.echo_.Get();
}
inline void CMsgSteamDatagramGameserverPingReplyData::_internal_set_echo(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.echo_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramGameserverPingReplyData::_internal_mutable_echo() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.echo_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramGameserverPingReplyData::release_echo() {
  // @@protoc_insertion_point(field_release:CMsgSteamDatagramGameserverPingReplyData.echo)
  if (!_internal_has_echo()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.echo_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.echo_.IsDefault()) {
    _impl_.echo_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgSteamDatagramGameserverPingReplyData::set_allocated_echo(std::string* echo) {
  if (echo != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.echo_.SetAllocated(echo, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.echo_.IsDefault()) {
    _impl_.echo_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamDatagramGameserverPingReplyData.echo)
}

// optional fixed64 legacy_challenge = 3;
inline bool CMsgSteamDatagramGameserverPingReplyData::_internal_has_legacy_challenge() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CMsgSteamDatagramGameserverPingReplyData::has_legacy_challenge() const {
  return _internal_has_legacy_challenge();
}
inline void CMsgSteamDatagramGameserverPingReplyData::clear_legacy_challenge() {
  _impl_.legacy_challenge_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint64_t CMsgSteamDatagramGameserverPingReplyData::_internal_legacy_challenge() const {
  return _impl_.legacy_challenge_;
}
inline uint64_t CMsgSteamDatagramGameserverPingReplyData::legacy_challenge() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramGameserverPingReplyData.legacy_challenge)
  return _internal_legacy_challenge();
}
inline void CMsgSteamDatagramGameserverPingReplyData::_internal_set_legacy_challenge(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.legacy_challenge_ = value;
}
inline void CMsgSteamDatagramGameserverPingReplyData::set_legacy_challenge(uint64_t value) {
  _internal_set_legacy_challenge(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramGameserverPingReplyData.legacy_challenge)
}

// optional fixed32 legacy_router_timestamp = 4;
inline bool CMsgSteamDatagramGameserverPingReplyData::_internal_has_legacy_router_timestamp() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool CMsgSteamDatagramGameserverPingReplyData::has_legacy_router_timestamp() const {
  return _internal_has_legacy_router_timestamp();
}
inline void CMsgSteamDatagramGameserverPingReplyData::clear_legacy_router_timestamp() {
  _impl_.legacy_router_timestamp_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline uint32_t CMsgSteamDatagramGameserverPingReplyData::_internal_legacy_router_timestamp() const {
  return _impl_.legacy_router_timestamp_;
}
inline uint32_t CMsgSteamDatagramGameserverPingReplyData::legacy_router_timestamp() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramGameserverPingReplyData.legacy_router_timestamp)
  return _internal_legacy_router_timestamp();
}
inline void CMsgSteamDatagramGameserverPingReplyData::_internal_set_legacy_router_timestamp(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.legacy_router_timestamp_ = value;
}
inline void CMsgSteamDatagramGameserverPingReplyData::set_legacy_router_timestamp(uint32_t value) {
  _internal_set_legacy_router_timestamp(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramGameserverPingReplyData.legacy_router_timestamp)
}

// optional fixed32 data_center_id = 5;
inline bool CMsgSteamDatagramGameserverPingReplyData::_internal_has_data_center_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool CMsgSteamDatagramGameserverPingReplyData::has_data_center_id() const {
  return _internal_has_data_center_id();
}
inline void CMsgSteamDatagramGameserverPingReplyData::clear_data_center_id() {
  _impl_.data_center_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline uint32_t CMsgSteamDatagramGameserverPingReplyData::_internal_data_center_id() const {
  return _impl_.data_center_id_;
}
inline uint32_t CMsgSteamDatagramGameserverPingReplyData::data_center_id() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramGameserverPingReplyData.data_center_id)
  return _internal_data_center_id();
}
inline void CMsgSteamDatagramGameserverPingReplyData::_internal_set_data_center_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.data_center_id_ = value;
}
inline void CMsgSteamDatagramGameserverPingReplyData::set_data_center_id(uint32_t value) {
  _internal_set_data_center_id(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramGameserverPingReplyData.data_center_id)
}

// optional uint32 appid = 6;
inline bool CMsgSteamDatagramGameserverPingReplyData::_internal_has_appid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool CMsgSteamDatagramGameserverPingReplyData::has_appid() const {
  return _internal_has_appid();
}
inline void CMsgSteamDatagramGameserverPingReplyData::clear_appid() {
  _impl_.appid_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline uint32_t CMsgSteamDatagramGameserverPingReplyData::_internal_appid() const {
  return _impl_.appid_;
}
inline uint32_t CMsgSteamDatagramGameserverPingReplyData::appid() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramGameserverPingReplyData.appid)
  return _internal_appid();
}
inline void CMsgSteamDatagramGameserverPingReplyData::_internal_set_appid(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.appid_ = value;
}
inline void CMsgSteamDatagramGameserverPingReplyData::set_appid(uint32_t value) {
  _internal_set_appid(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramGameserverPingReplyData.appid)
}

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

// optional string build = 9;
inline bool CMsgSteamDatagramGameserverPingReplyData::_internal_has_build() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgSteamDatagramGameserverPingReplyData::has_build() const {
  return _internal_has_build();
}
inline void CMsgSteamDatagramGameserverPingReplyData::clear_build() {
  _impl_.build_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& CMsgSteamDatagramGameserverPingReplyData::build() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramGameserverPingReplyData.build)
  return _internal_build();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgSteamDatagramGameserverPingReplyData::set_build(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.build_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramGameserverPingReplyData.build)
}
inline std::string* CMsgSteamDatagramGameserverPingReplyData::mutable_build() {
  std::string* _s = _internal_mutable_build();
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramGameserverPingReplyData.build)
  return _s;
}
inline const std::string& CMsgSteamDatagramGameserverPingReplyData::_internal_build() const {
  return _impl_.build_.Get();
}
inline void CMsgSteamDatagramGameserverPingReplyData::_internal_set_build(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.build_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramGameserverPingReplyData::_internal_mutable_build() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.build_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramGameserverPingReplyData::release_build() {
  // @@protoc_insertion_point(field_release:CMsgSteamDatagramGameserverPingReplyData.build)
  if (!_internal_has_build()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.build_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.build_.IsDefault()) {
    _impl_.build_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgSteamDatagramGameserverPingReplyData::set_allocated_build(std::string* build) {
  if (build != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.build_.SetAllocated(build, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.build_.IsDefault()) {
    _impl_.build_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamDatagramGameserverPingReplyData.build)
}

// optional uint64 network_config_version = 10;
inline bool CMsgSteamDatagramGameserverPingReplyData::_internal_has_network_config_version() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool CMsgSteamDatagramGameserverPingReplyData::has_network_config_version() const {
  return _internal_has_network_config_version();
}
inline void CMsgSteamDatagramGameserverPingReplyData::clear_network_config_version() {
  _impl_.network_config_version_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline uint64_t CMsgSteamDatagramGameserverPingReplyData::_internal_network_config_version() const {
  return _impl_.network_config_version_;
}
inline uint64_t CMsgSteamDatagramGameserverPingReplyData::network_config_version() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramGameserverPingReplyData.network_config_version)
  return _internal_network_config_version();
}
inline void CMsgSteamDatagramGameserverPingReplyData::_internal_set_network_config_version(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000400u;
  _impl_.network_config_version_ = value;
}
inline void CMsgSteamDatagramGameserverPingReplyData::set_network_config_version(uint64_t value) {
  _internal_set_network_config_version(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramGameserverPingReplyData.network_config_version)
}

// optional fixed32 my_unix_time = 11;
inline bool CMsgSteamDatagramGameserverPingReplyData::_internal_has_my_unix_time() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool CMsgSteamDatagramGameserverPingReplyData::has_my_unix_time() const {
  return _internal_has_my_unix_time();
}
inline void CMsgSteamDatagramGameserverPingReplyData::clear_my_unix_time() {
  _impl_.my_unix_time_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline uint32_t CMsgSteamDatagramGameserverPingReplyData::_internal_my_unix_time() const {
  return _impl_.my_unix_time_;
}
inline uint32_t CMsgSteamDatagramGameserverPingReplyData::my_unix_time() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramGameserverPingReplyData.my_unix_time)
  return _internal_my_unix_time();
}
inline void CMsgSteamDatagramGameserverPingReplyData::_internal_set_my_unix_time(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.my_unix_time_ = value;
}
inline void CMsgSteamDatagramGameserverPingReplyData::set_my_unix_time(uint32_t value) {
  _internal_set_my_unix_time(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramGameserverPingReplyData.my_unix_time)
}

// optional bytes routing_blob = 12;
inline bool CMsgSteamDatagramGameserverPingReplyData::_internal_has_routing_blob() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgSteamDatagramGameserverPingReplyData::has_routing_blob() const {
  return _internal_has_routing_blob();
}
inline void CMsgSteamDatagramGameserverPingReplyData::clear_routing_blob() {
  _impl_.routing_blob_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& CMsgSteamDatagramGameserverPingReplyData::routing_blob() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramGameserverPingReplyData.routing_blob)
  return _internal_routing_blob();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgSteamDatagramGameserverPingReplyData::set_routing_blob(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.routing_blob_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramGameserverPingReplyData.routing_blob)
}
inline std::string* CMsgSteamDatagramGameserverPingReplyData::mutable_routing_blob() {
  std::string* _s = _internal_mutable_routing_blob();
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramGameserverPingReplyData.routing_blob)
  return _s;
}
inline const std::string& CMsgSteamDatagramGameserverPingReplyData::_internal_routing_blob() const {
  return _impl_.routing_blob_.Get();
}
inline void CMsgSteamDatagramGameserverPingReplyData::_internal_set_routing_blob(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.routing_blob_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramGameserverPingReplyData::_internal_mutable_routing_blob() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.routing_blob_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramGameserverPingReplyData::release_routing_blob() {
  // @@protoc_insertion_point(field_release:CMsgSteamDatagramGameserverPingReplyData.routing_blob)
  if (!_internal_has_routing_blob()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* p = _impl_.routing_blob_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.routing_blob_.IsDefault()) {
    _impl_.routing_blob_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgSteamDatagramGameserverPingReplyData::set_allocated_routing_blob(std::string* routing_blob) {
  if (routing_blob != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.routing_blob_.SetAllocated(routing_blob, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.routing_blob_.IsDefault()) {
    _impl_.routing_blob_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamDatagramGameserverPingReplyData.routing_blob)
}

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

// CMsgSteamDatagramNoSessionRelayToClient

// optional fixed32 connection_id = 7;
inline bool CMsgSteamDatagramNoSessionRelayToClient::_internal_has_connection_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool CMsgSteamDatagramNoSessionRelayToClient::has_connection_id() const {
  return _internal_has_connection_id();
}
inline void CMsgSteamDatagramNoSessionRelayToClient::clear_connection_id() {
  _impl_.connection_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline uint32_t CMsgSteamDatagramNoSessionRelayToClient::_internal_connection_id() const {
  return _impl_.connection_id_;
}
inline uint32_t CMsgSteamDatagramNoSessionRelayToClient::connection_id() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramNoSessionRelayToClient.connection_id)
  return _internal_connection_id();
}
inline void CMsgSteamDatagramNoSessionRelayToClient::_internal_set_connection_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.connection_id_ = value;
}
inline void CMsgSteamDatagramNoSessionRelayToClient::set_connection_id(uint32_t value) {
  _internal_set_connection_id(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramNoSessionRelayToClient.connection_id)
}

// optional fixed32 your_public_ip = 2;
inline bool CMsgSteamDatagramNoSessionRelayToClient::_internal_has_your_public_ip() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgSteamDatagramNoSessionRelayToClient::has_your_public_ip() const {
  return _internal_has_your_public_ip();
}
inline void CMsgSteamDatagramNoSessionRelayToClient::clear_your_public_ip() {
  _impl_.your_public_ip_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t CMsgSteamDatagramNoSessionRelayToClient::_internal_your_public_ip() const {
  return _impl_.your_public_ip_;
}
inline uint32_t CMsgSteamDatagramNoSessionRelayToClient::your_public_ip() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramNoSessionRelayToClient.your_public_ip)
  return _internal_your_public_ip();
}
inline void CMsgSteamDatagramNoSessionRelayToClient::_internal_set_your_public_ip(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.your_public_ip_ = value;
}
inline void CMsgSteamDatagramNoSessionRelayToClient::set_your_public_ip(uint32_t value) {
  _internal_set_your_public_ip(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramNoSessionRelayToClient.your_public_ip)
}

// optional fixed32 your_public_port = 6;
inline bool CMsgSteamDatagramNoSessionRelayToClient::_internal_has_your_public_port() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CMsgSteamDatagramNoSessionRelayToClient::has_your_public_port() const {
  return _internal_has_your_public_port();
}
inline void CMsgSteamDatagramNoSessionRelayToClient::clear_your_public_port() {
  _impl_.your_public_port_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline uint32_t CMsgSteamDatagramNoSessionRelayToClient::_internal_your_public_port() const {
  return _impl_.your_public_port_;
}
inline uint32_t CMsgSteamDatagramNoSessionRelayToClient::your_public_port() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramNoSessionRelayToClient.your_public_port)
  return _internal_your_public_port();
}
inline void CMsgSteamDatagramNoSessionRelayToClient::_internal_set_your_public_port(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.your_public_port_ = value;
}
inline void CMsgSteamDatagramNoSessionRelayToClient::set_your_public_port(uint32_t value) {
  _internal_set_your_public_port(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramNoSessionRelayToClient.your_public_port)
}

// optional fixed32 server_time = 3;
inline bool CMsgSteamDatagramNoSessionRelayToClient::_internal_has_server_time() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgSteamDatagramNoSessionRelayToClient::has_server_time() const {
  return _internal_has_server_time();
}
inline void CMsgSteamDatagramNoSessionRelayToClient::clear_server_time() {
  _impl_.server_time_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t CMsgSteamDatagramNoSessionRelayToClient::_internal_server_time() const {
  return _impl_.server_time_;
}
inline uint32_t CMsgSteamDatagramNoSessionRelayToClient::server_time() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramNoSessionRelayToClient.server_time)
  return _internal_server_time();
}
inline void CMsgSteamDatagramNoSessionRelayToClient::_internal_set_server_time(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.server_time_ = value;
}
inline void CMsgSteamDatagramNoSessionRelayToClient::set_server_time(uint32_t value) {
  _internal_set_server_time(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramNoSessionRelayToClient.server_time)
}

// optional fixed64 challenge = 4;
inline bool CMsgSteamDatagramNoSessionRelayToClient::_internal_has_challenge() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgSteamDatagramNoSessionRelayToClient::has_challenge() const {
  return _internal_has_challenge();
}
inline void CMsgSteamDatagramNoSessionRelayToClient::clear_challenge() {
  _impl_.challenge_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint64_t CMsgSteamDatagramNoSessionRelayToClient::_internal_challenge() const {
  return _impl_.challenge_;
}
inline uint64_t CMsgSteamDatagramNoSessionRelayToClient::challenge() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramNoSessionRelayToClient.challenge)
  return _internal_challenge();
}
inline void CMsgSteamDatagramNoSessionRelayToClient::_internal_set_challenge(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.challenge_ = value;
}
inline void CMsgSteamDatagramNoSessionRelayToClient::set_challenge(uint64_t value) {
  _internal_set_challenge(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramNoSessionRelayToClient.challenge)
}

// optional uint32 seconds_until_shutdown = 5;
inline bool CMsgSteamDatagramNoSessionRelayToClient::_internal_has_seconds_until_shutdown() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CMsgSteamDatagramNoSessionRelayToClient::has_seconds_until_shutdown() const {
  return _internal_has_seconds_until_shutdown();
}
inline void CMsgSteamDatagramNoSessionRelayToClient::clear_seconds_until_shutdown() {
  _impl_.seconds_until_shutdown_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t CMsgSteamDatagramNoSessionRelayToClient::_internal_seconds_until_shutdown() const {
  return _impl_.seconds_until_shutdown_;
}
inline uint32_t CMsgSteamDatagramNoSessionRelayToClient::seconds_until_shutdown() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramNoSessionRelayToClient.seconds_until_shutdown)
  return _internal_seconds_until_shutdown();
}
inline void CMsgSteamDatagramNoSessionRelayToClient::_internal_set_seconds_until_shutdown(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.seconds_until_shutdown_ = value;
}
inline void CMsgSteamDatagramNoSessionRelayToClient::set_seconds_until_shutdown(uint32_t value) {
  _internal_set_seconds_until_shutdown(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramNoSessionRelayToClient.seconds_until_shutdown)
}

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

// CMsgSteamDatagramNoSessionRelayToPeer

// optional uint32 legacy_relay_session_id = 1;
inline bool CMsgSteamDatagramNoSessionRelayToPeer::_internal_has_legacy_relay_session_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgSteamDatagramNoSessionRelayToPeer::has_legacy_relay_session_id() const {
  return _internal_has_legacy_relay_session_id();
}
inline void CMsgSteamDatagramNoSessionRelayToPeer::clear_legacy_relay_session_id() {
  _impl_.legacy_relay_session_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t CMsgSteamDatagramNoSessionRelayToPeer::_internal_legacy_relay_session_id() const {
  return _impl_.legacy_relay_session_id_;
}
inline uint32_t CMsgSteamDatagramNoSessionRelayToPeer::legacy_relay_session_id() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramNoSessionRelayToPeer.legacy_relay_session_id)
  return _internal_legacy_relay_session_id();
}
inline void CMsgSteamDatagramNoSessionRelayToPeer::_internal_set_legacy_relay_session_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.legacy_relay_session_id_ = value;
}
inline void CMsgSteamDatagramNoSessionRelayToPeer::set_legacy_relay_session_id(uint32_t value) {
  _internal_set_legacy_relay_session_id(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramNoSessionRelayToPeer.legacy_relay_session_id)
}

// optional fixed32 from_relay_session_id = 2;
inline bool CMsgSteamDatagramNoSessionRelayToPeer::_internal_has_from_relay_session_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgSteamDatagramNoSessionRelayToPeer::has_from_relay_session_id() const {
  return _internal_has_from_relay_session_id();
}
inline void CMsgSteamDatagramNoSessionRelayToPeer::clear_from_relay_session_id() {
  _impl_.from_relay_session_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t CMsgSteamDatagramNoSessionRelayToPeer::_internal_from_relay_session_id() const {
  return _impl_.from_relay_session_id_;
}
inline uint32_t CMsgSteamDatagramNoSessionRelayToPeer::from_relay_session_id() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramNoSessionRelayToPeer.from_relay_session_id)
  return _internal_from_relay_session_id();
}
inline void CMsgSteamDatagramNoSessionRelayToPeer::_internal_set_from_relay_session_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.from_relay_session_id_ = value;
}
inline void CMsgSteamDatagramNoSessionRelayToPeer::set_from_relay_session_id(uint32_t value) {
  _internal_set_from_relay_session_id(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramNoSessionRelayToPeer.from_relay_session_id)
}

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

// optional fixed64 kludge_pad = 99;
inline bool CMsgSteamDatagramNoSessionRelayToPeer::_internal_has_kludge_pad() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgSteamDatagramNoSessionRelayToPeer::has_kludge_pad() const {
  return _internal_has_kludge_pad();
}
inline void CMsgSteamDatagramNoSessionRelayToPeer::clear_kludge_pad() {
  _impl_.kludge_pad_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint64_t CMsgSteamDatagramNoSessionRelayToPeer::_internal_kludge_pad() const {
  return _impl_.kludge_pad_;
}
inline uint64_t CMsgSteamDatagramNoSessionRelayToPeer::kludge_pad() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramNoSessionRelayToPeer.kludge_pad)
  return _internal_kludge_pad();
}
inline void CMsgSteamDatagramNoSessionRelayToPeer::_internal_set_kludge_pad(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.kludge_pad_ = value;
}
inline void CMsgSteamDatagramNoSessionRelayToPeer::set_kludge_pad(uint64_t value) {
  _internal_set_kludge_pad(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramNoSessionRelayToPeer.kludge_pad)
}

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

// CMsgTOSTreatment

// optional string l4s_detect = 1;
inline bool CMsgTOSTreatment::_internal_has_l4s_detect() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgTOSTreatment::has_l4s_detect() const {
  return _internal_has_l4s_detect();
}
inline void CMsgTOSTreatment::clear_l4s_detect() {
  _impl_.l4s_detect_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CMsgTOSTreatment::l4s_detect() const {
  // @@protoc_insertion_point(field_get:CMsgTOSTreatment.l4s_detect)
  return _internal_l4s_detect();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgTOSTreatment::set_l4s_detect(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.l4s_detect_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgTOSTreatment.l4s_detect)
}
inline std::string* CMsgTOSTreatment::mutable_l4s_detect() {
  std::string* _s = _internal_mutable_l4s_detect();
  // @@protoc_insertion_point(field_mutable:CMsgTOSTreatment.l4s_detect)
  return _s;
}
inline const std::string& CMsgTOSTreatment::_internal_l4s_detect() const {
  return _impl_.l4s_detect_.Get();
}
inline void CMsgTOSTreatment::_internal_set_l4s_detect(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.l4s_detect_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgTOSTreatment::_internal_mutable_l4s_detect() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.l4s_detect_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgTOSTreatment::release_l4s_detect() {
  // @@protoc_insertion_point(field_release:CMsgTOSTreatment.l4s_detect)
  if (!_internal_has_l4s_detect()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.l4s_detect_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.l4s_detect_.IsDefault()) {
    _impl_.l4s_detect_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgTOSTreatment::set_allocated_l4s_detect(std::string* l4s_detect) {
  if (l4s_detect != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.l4s_detect_.SetAllocated(l4s_detect, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.l4s_detect_.IsDefault()) {
    _impl_.l4s_detect_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgTOSTreatment.l4s_detect)
}

// optional string up_ecn1 = 2;
inline bool CMsgTOSTreatment::_internal_has_up_ecn1() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgTOSTreatment::has_up_ecn1() const {
  return _internal_has_up_ecn1();
}
inline void CMsgTOSTreatment::clear_up_ecn1() {
  _impl_.up_ecn1_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& CMsgTOSTreatment::up_ecn1() const {
  // @@protoc_insertion_point(field_get:CMsgTOSTreatment.up_ecn1)
  return _internal_up_ecn1();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgTOSTreatment::set_up_ecn1(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.up_ecn1_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgTOSTreatment.up_ecn1)
}
inline std::string* CMsgTOSTreatment::mutable_up_ecn1() {
  std::string* _s = _internal_mutable_up_ecn1();
  // @@protoc_insertion_point(field_mutable:CMsgTOSTreatment.up_ecn1)
  return _s;
}
inline const std::string& CMsgTOSTreatment::_internal_up_ecn1() const {
  return _impl_.up_ecn1_.Get();
}
inline void CMsgTOSTreatment::_internal_set_up_ecn1(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.up_ecn1_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgTOSTreatment::_internal_mutable_up_ecn1() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.up_ecn1_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgTOSTreatment::release_up_ecn1() {
  // @@protoc_insertion_point(field_release:CMsgTOSTreatment.up_ecn1)
  if (!_internal_has_up_ecn1()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.up_ecn1_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.up_ecn1_.IsDefault()) {
    _impl_.up_ecn1_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgTOSTreatment::set_allocated_up_ecn1(std::string* up_ecn1) {
  if (up_ecn1 != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.up_ecn1_.SetAllocated(up_ecn1, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.up_ecn1_.IsDefault()) {
    _impl_.up_ecn1_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgTOSTreatment.up_ecn1)
}

// optional string down_dscp45 = 3;
inline bool CMsgTOSTreatment::_internal_has_down_dscp45() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgTOSTreatment::has_down_dscp45() const {
  return _internal_has_down_dscp45();
}
inline void CMsgTOSTreatment::clear_down_dscp45() {
  _impl_.down_dscp45_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& CMsgTOSTreatment::down_dscp45() const {
  // @@protoc_insertion_point(field_get:CMsgTOSTreatment.down_dscp45)
  return _internal_down_dscp45();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgTOSTreatment::set_down_dscp45(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.down_dscp45_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgTOSTreatment.down_dscp45)
}
inline std::string* CMsgTOSTreatment::mutable_down_dscp45() {
  std::string* _s = _internal_mutable_down_dscp45();
  // @@protoc_insertion_point(field_mutable:CMsgTOSTreatment.down_dscp45)
  return _s;
}
inline const std::string& CMsgTOSTreatment::_internal_down_dscp45() const {
  return _impl_.down_dscp45_.Get();
}
inline void CMsgTOSTreatment::_internal_set_down_dscp45(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.down_dscp45_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgTOSTreatment::_internal_mutable_down_dscp45() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.down_dscp45_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgTOSTreatment::release_down_dscp45() {
  // @@protoc_insertion_point(field_release:CMsgTOSTreatment.down_dscp45)
  if (!_internal_has_down_dscp45()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* p = _impl_.down_dscp45_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.down_dscp45_.IsDefault()) {
    _impl_.down_dscp45_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgTOSTreatment::set_allocated_down_dscp45(std::string* down_dscp45) {
  if (down_dscp45 != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.down_dscp45_.SetAllocated(down_dscp45, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.down_dscp45_.IsDefault()) {
    _impl_.down_dscp45_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgTOSTreatment.down_dscp45)
}

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

// CMsgSteamDatagramClientPingSampleRequest

// optional fixed32 connection_id = 1;
inline bool CMsgSteamDatagramClientPingSampleRequest::_internal_has_connection_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgSteamDatagramClientPingSampleRequest::has_connection_id() const {
  return _internal_has_connection_id();
}
inline void CMsgSteamDatagramClientPingSampleRequest::clear_connection_id() {
  _impl_.connection_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t CMsgSteamDatagramClientPingSampleRequest::_internal_connection_id() const {
  return _impl_.connection_id_;
}
inline uint32_t CMsgSteamDatagramClientPingSampleRequest::connection_id() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramClientPingSampleRequest.connection_id)
  return _internal_connection_id();
}
inline void CMsgSteamDatagramClientPingSampleRequest::_internal_set_connection_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.connection_id_ = value;
}
inline void CMsgSteamDatagramClientPingSampleRequest::set_connection_id(uint32_t value) {
  _internal_set_connection_id(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramClientPingSampleRequest.connection_id)
}

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

// CMsgSteamDatagramClientPingSampleReply_POP_AltAddress

// optional string id = 1;
inline bool CMsgSteamDatagramClientPingSampleReply_POP_AltAddress::_internal_has_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgSteamDatagramClientPingSampleReply_POP_AltAddress::has_id() const {
  return _internal_has_id();
}
inline void CMsgSteamDatagramClientPingSampleReply_POP_AltAddress::clear_id() {
  _impl_.id_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CMsgSteamDatagramClientPingSampleReply_POP_AltAddress::id() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramClientPingSampleReply.POP.AltAddress.id)
  return _internal_id();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgSteamDatagramClientPingSampleReply_POP_AltAddress::set_id(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.id_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramClientPingSampleReply.POP.AltAddress.id)
}
inline std::string* CMsgSteamDatagramClientPingSampleReply_POP_AltAddress::mutable_id() {
  std::string* _s = _internal_mutable_id();
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramClientPingSampleReply.POP.AltAddress.id)
  return _s;
}
inline const std::string& CMsgSteamDatagramClientPingSampleReply_POP_AltAddress::_internal_id() const {
  return _impl_.id_.Get();
}
inline void CMsgSteamDatagramClientPingSampleReply_POP_AltAddress::_internal_set_id(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.id_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramClientPingSampleReply_POP_AltAddress::_internal_mutable_id() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.id_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramClientPingSampleReply_POP_AltAddress::release_id() {
  // @@protoc_insertion_point(field_release:CMsgSteamDatagramClientPingSampleReply.POP.AltAddress.id)
  if (!_internal_has_id()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.id_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.id_.IsDefault()) {
    _impl_.id_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgSteamDatagramClientPingSampleReply_POP_AltAddress::set_allocated_id(std::string* id) {
  if (id != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.id_.SetAllocated(id, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.id_.IsDefault()) {
    _impl_.id_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamDatagramClientPingSampleReply.POP.AltAddress.id)
}

// optional uint32 front_ping_ms = 2;
inline bool CMsgSteamDatagramClientPingSampleReply_POP_AltAddress::_internal_has_front_ping_ms() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgSteamDatagramClientPingSampleReply_POP_AltAddress::has_front_ping_ms() const {
  return _internal_has_front_ping_ms();
}
inline void CMsgSteamDatagramClientPingSampleReply_POP_AltAddress::clear_front_ping_ms() {
  _impl_.front_ping_ms_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t CMsgSteamDatagramClientPingSampleReply_POP_AltAddress::_internal_front_ping_ms() const {
  return _impl_.front_ping_ms_;
}
inline uint32_t CMsgSteamDatagramClientPingSampleReply_POP_AltAddress::front_ping_ms() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramClientPingSampleReply.POP.AltAddress.front_ping_ms)
  return _internal_front_ping_ms();
}
inline void CMsgSteamDatagramClientPingSampleReply_POP_AltAddress::_internal_set_front_ping_ms(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.front_ping_ms_ = value;
}
inline void CMsgSteamDatagramClientPingSampleReply_POP_AltAddress::set_front_ping_ms(uint32_t value) {
  _internal_set_front_ping_ms(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramClientPingSampleReply.POP.AltAddress.front_ping_ms)
}

// optional uint32 penalty = 3;
inline bool CMsgSteamDatagramClientPingSampleReply_POP_AltAddress::_internal_has_penalty() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgSteamDatagramClientPingSampleReply_POP_AltAddress::has_penalty() const {
  return _internal_has_penalty();
}
inline void CMsgSteamDatagramClientPingSampleReply_POP_AltAddress::clear_penalty() {
  _impl_.penalty_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t CMsgSteamDatagramClientPingSampleReply_POP_AltAddress::_internal_penalty() const {
  return _impl_.penalty_;
}
inline uint32_t CMsgSteamDatagramClientPingSampleReply_POP_AltAddress::penalty() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramClientPingSampleReply.POP.AltAddress.penalty)
  return _internal_penalty();
}
inline void CMsgSteamDatagramClientPingSampleReply_POP_AltAddress::_internal_set_penalty(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.penalty_ = value;
}
inline void CMsgSteamDatagramClientPingSampleReply_POP_AltAddress::set_penalty(uint32_t value) {
  _internal_set_penalty(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramClientPingSampleReply.POP.AltAddress.penalty)
}

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

// CMsgSteamDatagramClientPingSampleReply_POP

// optional fixed32 pop_id = 1;
inline bool CMsgSteamDatagramClientPingSampleReply_POP::_internal_has_pop_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgSteamDatagramClientPingSampleReply_POP::has_pop_id() const {
  return _internal_has_pop_id();
}
inline void CMsgSteamDatagramClientPingSampleReply_POP::clear_pop_id() {
  _impl_.pop_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t CMsgSteamDatagramClientPingSampleReply_POP::_internal_pop_id() const {
  return _impl_.pop_id_;
}
inline uint32_t CMsgSteamDatagramClientPingSampleReply_POP::pop_id() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramClientPingSampleReply.POP.pop_id)
  return _internal_pop_id();
}
inline void CMsgSteamDatagramClientPingSampleReply_POP::_internal_set_pop_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.pop_id_ = value;
}
inline void CMsgSteamDatagramClientPingSampleReply_POP::set_pop_id(uint32_t value) {
  _internal_set_pop_id(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramClientPingSampleReply.POP.pop_id)
}

// optional uint32 default_front_ping_ms = 2;
inline bool CMsgSteamDatagramClientPingSampleReply_POP::_internal_has_default_front_ping_ms() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgSteamDatagramClientPingSampleReply_POP::has_default_front_ping_ms() const {
  return _internal_has_default_front_ping_ms();
}
inline void CMsgSteamDatagramClientPingSampleReply_POP::clear_default_front_ping_ms() {
  _impl_.default_front_ping_ms_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t CMsgSteamDatagramClientPingSampleReply_POP::_internal_default_front_ping_ms() const {
  return _impl_.default_front_ping_ms_;
}
inline uint32_t CMsgSteamDatagramClientPingSampleReply_POP::default_front_ping_ms() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramClientPingSampleReply.POP.default_front_ping_ms)
  return _internal_default_front_ping_ms();
}
inline void CMsgSteamDatagramClientPingSampleReply_POP::_internal_set_default_front_ping_ms(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.default_front_ping_ms_ = value;
}
inline void CMsgSteamDatagramClientPingSampleReply_POP::set_default_front_ping_ms(uint32_t value) {
  _internal_set_default_front_ping_ms(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramClientPingSampleReply.POP.default_front_ping_ms)
}

// optional uint32 cluster_penalty = 4;
inline bool CMsgSteamDatagramClientPingSampleReply_POP::_internal_has_cluster_penalty() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CMsgSteamDatagramClientPingSampleReply_POP::has_cluster_penalty() const {
  return _internal_has_cluster_penalty();
}
inline void CMsgSteamDatagramClientPingSampleReply_POP::clear_cluster_penalty() {
  _impl_.cluster_penalty_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t CMsgSteamDatagramClientPingSampleReply_POP::_internal_cluster_penalty() const {
  return _impl_.cluster_penalty_;
}
inline uint32_t CMsgSteamDatagramClientPingSampleReply_POP::cluster_penalty() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramClientPingSampleReply.POP.cluster_penalty)
  return _internal_cluster_penalty();
}
inline void CMsgSteamDatagramClientPingSampleReply_POP::_internal_set_cluster_penalty(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.cluster_penalty_ = value;
}
inline void CMsgSteamDatagramClientPingSampleReply_POP::set_cluster_penalty(uint32_t value) {
  _internal_set_cluster_penalty(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramClientPingSampleReply.POP.cluster_penalty)
}

// repeated .CMsgSteamDatagramClientPingSampleReply.POP.AltAddress alt_addresses = 7;
inline int CMsgSteamDatagramClientPingSampleReply_POP::_internal_alt_addresses_size() const {
  return _impl_.alt_addresses_.size();
}
inline int CMsgSteamDatagramClientPingSampleReply_POP::alt_addresses_size() const {
  return _internal_alt_addresses_size();
}
inline void CMsgSteamDatagramClientPingSampleReply_POP::clear_alt_addresses() {
  _impl_.alt_addresses_.Clear();
}
inline ::CMsgSteamDatagramClientPingSampleReply_POP_AltAddress* CMsgSteamDatagramClientPingSampleReply_POP::mutable_alt_addresses(int index) {
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramClientPingSampleReply.POP.alt_addresses)
  return _impl_.alt_addresses_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgSteamDatagramClientPingSampleReply_POP_AltAddress >*
CMsgSteamDatagramClientPingSampleReply_POP::mutable_alt_addresses() {
  // @@protoc_insertion_point(field_mutable_list:CMsgSteamDatagramClientPingSampleReply.POP.alt_addresses)
  return &_impl_.alt_addresses_;
}
inline const ::CMsgSteamDatagramClientPingSampleReply_POP_AltAddress& CMsgSteamDatagramClientPingSampleReply_POP::_internal_alt_addresses(int index) const {
  return _impl_.alt_addresses_.Get(index);
}
inline const ::CMsgSteamDatagramClientPingSampleReply_POP_AltAddress& CMsgSteamDatagramClientPingSampleReply_POP::alt_addresses(int index) const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramClientPingSampleReply.POP.alt_addresses)
  return _internal_alt_addresses(index);
}
inline ::CMsgSteamDatagramClientPingSampleReply_POP_AltAddress* CMsgSteamDatagramClientPingSampleReply_POP::_internal_add_alt_addresses() {
  return _impl_.alt_addresses_.Add();
}
inline ::CMsgSteamDatagramClientPingSampleReply_POP_AltAddress* CMsgSteamDatagramClientPingSampleReply_POP::add_alt_addresses() {
  ::CMsgSteamDatagramClientPingSampleReply_POP_AltAddress* _add = _internal_add_alt_addresses();
  // @@protoc_insertion_point(field_add:CMsgSteamDatagramClientPingSampleReply.POP.alt_addresses)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgSteamDatagramClientPingSampleReply_POP_AltAddress >&
CMsgSteamDatagramClientPingSampleReply_POP::alt_addresses() const {
  // @@protoc_insertion_point(field_list:CMsgSteamDatagramClientPingSampleReply.POP.alt_addresses)
  return _impl_.alt_addresses_;
}

// optional uint32 default_e2e_ping_ms = 3;
inline bool CMsgSteamDatagramClientPingSampleReply_POP::_internal_has_default_e2e_ping_ms() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgSteamDatagramClientPingSampleReply_POP::has_default_e2e_ping_ms() const {
  return _internal_has_default_e2e_ping_ms();
}
inline void CMsgSteamDatagramClientPingSampleReply_POP::clear_default_e2e_ping_ms() {
  _impl_.default_e2e_ping_ms_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t CMsgSteamDatagramClientPingSampleReply_POP::_internal_default_e2e_ping_ms() const {
  return _impl_.default_e2e_ping_ms_;
}
inline uint32_t CMsgSteamDatagramClientPingSampleReply_POP::default_e2e_ping_ms() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramClientPingSampleReply.POP.default_e2e_ping_ms)
  return _internal_default_e2e_ping_ms();
}
inline void CMsgSteamDatagramClientPingSampleReply_POP::_internal_set_default_e2e_ping_ms(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.default_e2e_ping_ms_ = value;
}
inline void CMsgSteamDatagramClientPingSampleReply_POP::set_default_e2e_ping_ms(uint32_t value) {
  _internal_set_default_e2e_ping_ms(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramClientPingSampleReply.POP.default_e2e_ping_ms)
}

// optional uint32 default_e2e_score = 5;
inline bool CMsgSteamDatagramClientPingSampleReply_POP::_internal_has_default_e2e_score() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CMsgSteamDatagramClientPingSampleReply_POP::has_default_e2e_score() const {
  return _internal_has_default_e2e_score();
}
inline void CMsgSteamDatagramClientPingSampleReply_POP::clear_default_e2e_score() {
  _impl_.default_e2e_score_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline uint32_t CMsgSteamDatagramClientPingSampleReply_POP::_internal_default_e2e_score() const {
  return _impl_.default_e2e_score_;
}
inline uint32_t CMsgSteamDatagramClientPingSampleReply_POP::default_e2e_score() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramClientPingSampleReply.POP.default_e2e_score)
  return _internal_default_e2e_score();
}
inline void CMsgSteamDatagramClientPingSampleReply_POP::_internal_set_default_e2e_score(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.default_e2e_score_ = value;
}
inline void CMsgSteamDatagramClientPingSampleReply_POP::set_default_e2e_score(uint32_t value) {
  _internal_set_default_e2e_score(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramClientPingSampleReply.POP.default_e2e_score)
}

// optional fixed32 p2p_via_peer_relay_pop_id = 6;
inline bool CMsgSteamDatagramClientPingSampleReply_POP::_internal_has_p2p_via_peer_relay_pop_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool CMsgSteamDatagramClientPingSampleReply_POP::has_p2p_via_peer_relay_pop_id() const {
  return _internal_has_p2p_via_peer_relay_pop_id();
}
inline void CMsgSteamDatagramClientPingSampleReply_POP::clear_p2p_via_peer_relay_pop_id() {
  _impl_.p2p_via_peer_relay_pop_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline uint32_t CMsgSteamDatagramClientPingSampleReply_POP::_internal_p2p_via_peer_relay_pop_id() const {
  return _impl_.p2p_via_peer_relay_pop_id_;
}
inline uint32_t CMsgSteamDatagramClientPingSampleReply_POP::p2p_via_peer_relay_pop_id() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramClientPingSampleReply.POP.p2p_via_peer_relay_pop_id)
  return _internal_p2p_via_peer_relay_pop_id();
}
inline void CMsgSteamDatagramClientPingSampleReply_POP::_internal_set_p2p_via_peer_relay_pop_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.p2p_via_peer_relay_pop_id_ = value;
}
inline void CMsgSteamDatagramClientPingSampleReply_POP::set_p2p_via_peer_relay_pop_id(uint32_t value) {
  _internal_set_p2p_via_peer_relay_pop_id(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramClientPingSampleReply.POP.p2p_via_peer_relay_pop_id)
}

// optional uint32 best_dc_ping_ms = 9;
inline bool CMsgSteamDatagramClientPingSampleReply_POP::_internal_has_best_dc_ping_ms() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool CMsgSteamDatagramClientPingSampleReply_POP::has_best_dc_ping_ms() const {
  return _internal_has_best_dc_ping_ms();
}
inline void CMsgSteamDatagramClientPingSampleReply_POP::clear_best_dc_ping_ms() {
  _impl_.best_dc_ping_ms_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline uint32_t CMsgSteamDatagramClientPingSampleReply_POP::_internal_best_dc_ping_ms() const {
  return _impl_.best_dc_ping_ms_;
}
inline uint32_t CMsgSteamDatagramClientPingSampleReply_POP::best_dc_ping_ms() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramClientPingSampleReply.POP.best_dc_ping_ms)
  return _internal_best_dc_ping_ms();
}
inline void CMsgSteamDatagramClientPingSampleReply_POP::_internal_set_best_dc_ping_ms(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.best_dc_ping_ms_ = value;
}
inline void CMsgSteamDatagramClientPingSampleReply_POP::set_best_dc_ping_ms(uint32_t value) {
  _internal_set_best_dc_ping_ms(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramClientPingSampleReply.POP.best_dc_ping_ms)
}

// optional uint32 best_dc_score = 10;
inline bool CMsgSteamDatagramClientPingSampleReply_POP::_internal_has_best_dc_score() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool CMsgSteamDatagramClientPingSampleReply_POP::has_best_dc_score() const {
  return _internal_has_best_dc_score();
}
inline void CMsgSteamDatagramClientPingSampleReply_POP::clear_best_dc_score() {
  _impl_.best_dc_score_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline uint32_t CMsgSteamDatagramClientPingSampleReply_POP::_internal_best_dc_score() const {
  return _impl_.best_dc_score_;
}
inline uint32_t CMsgSteamDatagramClientPingSampleReply_POP::best_dc_score() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramClientPingSampleReply.POP.best_dc_score)
  return _internal_best_dc_score();
}
inline void CMsgSteamDatagramClientPingSampleReply_POP::_internal_set_best_dc_score(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.best_dc_score_ = value;
}
inline void CMsgSteamDatagramClientPingSampleReply_POP::set_best_dc_score(uint32_t value) {
  _internal_set_best_dc_score(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramClientPingSampleReply.POP.best_dc_score)
}

// optional fixed32 best_dc_via_relay_pop_id = 11;
inline bool CMsgSteamDatagramClientPingSampleReply_POP::_internal_has_best_dc_via_relay_pop_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool CMsgSteamDatagramClientPingSampleReply_POP::has_best_dc_via_relay_pop_id() const {
  return _internal_has_best_dc_via_relay_pop_id();
}
inline void CMsgSteamDatagramClientPingSampleReply_POP::clear_best_dc_via_relay_pop_id() {
  _impl_.best_dc_via_relay_pop_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline uint32_t CMsgSteamDatagramClientPingSampleReply_POP::_internal_best_dc_via_relay_pop_id() const {
  return _impl_.best_dc_via_relay_pop_id_;
}
inline uint32_t CMsgSteamDatagramClientPingSampleReply_POP::best_dc_via_relay_pop_id() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramClientPingSampleReply.POP.best_dc_via_relay_pop_id)
  return _internal_best_dc_via_relay_pop_id();
}
inline void CMsgSteamDatagramClientPingSampleReply_POP::_internal_set_best_dc_via_relay_pop_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.best_dc_via_relay_pop_id_ = value;
}
inline void CMsgSteamDatagramClientPingSampleReply_POP::set_best_dc_via_relay_pop_id(uint32_t value) {
  _internal_set_best_dc_via_relay_pop_id(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramClientPingSampleReply.POP.best_dc_via_relay_pop_id)
}

// optional uint32 default_dc_ping_ms = 12;
inline bool CMsgSteamDatagramClientPingSampleReply_POP::_internal_has_default_dc_ping_ms() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool CMsgSteamDatagramClientPingSampleReply_POP::has_default_dc_ping_ms() const {
  return _internal_has_default_dc_ping_ms();
}
inline void CMsgSteamDatagramClientPingSampleReply_POP::clear_default_dc_ping_ms() {
  _impl_.default_dc_ping_ms_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline uint32_t CMsgSteamDatagramClientPingSampleReply_POP::_internal_default_dc_ping_ms() const {
  return _impl_.default_dc_ping_ms_;
}
inline uint32_t CMsgSteamDatagramClientPingSampleReply_POP::default_dc_ping_ms() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramClientPingSampleReply.POP.default_dc_ping_ms)
  return _internal_default_dc_ping_ms();
}
inline void CMsgSteamDatagramClientPingSampleReply_POP::_internal_set_default_dc_ping_ms(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.default_dc_ping_ms_ = value;
}
inline void CMsgSteamDatagramClientPingSampleReply_POP::set_default_dc_ping_ms(uint32_t value) {
  _internal_set_default_dc_ping_ms(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramClientPingSampleReply.POP.default_dc_ping_ms)
}

// optional uint32 default_dc_score = 13;
inline bool CMsgSteamDatagramClientPingSampleReply_POP::_internal_has_default_dc_score() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool CMsgSteamDatagramClientPingSampleReply_POP::has_default_dc_score() const {
  return _internal_has_default_dc_score();
}
inline void CMsgSteamDatagramClientPingSampleReply_POP::clear_default_dc_score() {
  _impl_.default_dc_score_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline uint32_t CMsgSteamDatagramClientPingSampleReply_POP::_internal_default_dc_score() const {
  return _impl_.default_dc_score_;
}
inline uint32_t CMsgSteamDatagramClientPingSampleReply_POP::default_dc_score() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramClientPingSampleReply.POP.default_dc_score)
  return _internal_default_dc_score();
}
inline void CMsgSteamDatagramClientPingSampleReply_POP::_internal_set_default_dc_score(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000400u;
  _impl_.default_dc_score_ = value;
}
inline void CMsgSteamDatagramClientPingSampleReply_POP::set_default_dc_score(uint32_t value) {
  _internal_set_default_dc_score(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramClientPingSampleReply.POP.default_dc_score)
}

// optional fixed32 default_dc_via_relay_pop_id = 14;
inline bool CMsgSteamDatagramClientPingSampleReply_POP::_internal_has_default_dc_via_relay_pop_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
  return value;
}
inline bool CMsgSteamDatagramClientPingSampleReply_POP::has_default_dc_via_relay_pop_id() const {
  return _internal_has_default_dc_via_relay_pop_id();
}
inline void CMsgSteamDatagramClientPingSampleReply_POP::clear_default_dc_via_relay_pop_id() {
  _impl_.default_dc_via_relay_pop_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000800u;
}
inline uint32_t CMsgSteamDatagramClientPingSampleReply_POP::_internal_default_dc_via_relay_pop_id() const {
  return _impl_.default_dc_via_relay_pop_id_;
}
inline uint32_t CMsgSteamDatagramClientPingSampleReply_POP::default_dc_via_relay_pop_id() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramClientPingSampleReply.POP.default_dc_via_relay_pop_id)
  return _internal_default_dc_via_relay_pop_id();
}
inline void CMsgSteamDatagramClientPingSampleReply_POP::_internal_set_default_dc_via_relay_pop_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000800u;
  _impl_.default_dc_via_relay_pop_id_ = value;
}
inline void CMsgSteamDatagramClientPingSampleReply_POP::set_default_dc_via_relay_pop_id(uint32_t value) {
  _internal_set_default_dc_via_relay_pop_id(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramClientPingSampleReply.POP.default_dc_via_relay_pop_id)
}

// optional uint32 test_dc_ping_ms = 15;
inline bool CMsgSteamDatagramClientPingSampleReply_POP::_internal_has_test_dc_ping_ms() const {
  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
  return value;
}
inline bool CMsgSteamDatagramClientPingSampleReply_POP::has_test_dc_ping_ms() const {
  return _internal_has_test_dc_ping_ms();
}
inline void CMsgSteamDatagramClientPingSampleReply_POP::clear_test_dc_ping_ms() {
  _impl_.test_dc_ping_ms_ = 0u;
  _impl_._has_bits_[0] &= ~0x00001000u;
}
inline uint32_t CMsgSteamDatagramClientPingSampleReply_POP::_internal_test_dc_ping_ms() const {
  return _impl_.test_dc_ping_ms_;
}
inline uint32_t CMsgSteamDatagramClientPingSampleReply_POP::test_dc_ping_ms() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramClientPingSampleReply.POP.test_dc_ping_ms)
  return _internal_test_dc_ping_ms();
}
inline void CMsgSteamDatagramClientPingSampleReply_POP::_internal_set_test_dc_ping_ms(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00001000u;
  _impl_.test_dc_ping_ms_ = value;
}
inline void CMsgSteamDatagramClientPingSampleReply_POP::set_test_dc_ping_ms(uint32_t value) {
  _internal_set_test_dc_ping_ms(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramClientPingSampleReply.POP.test_dc_ping_ms)
}

// optional uint32 test_dc_score = 16;
inline bool CMsgSteamDatagramClientPingSampleReply_POP::_internal_has_test_dc_score() const {
  bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0;
  return value;
}
inline bool CMsgSteamDatagramClientPingSampleReply_POP::has_test_dc_score() const {
  return _internal_has_test_dc_score();
}
inline void CMsgSteamDatagramClientPingSampleReply_POP::clear_test_dc_score() {
  _impl_.test_dc_score_ = 0u;
  _impl_._has_bits_[0] &= ~0x00002000u;
}
inline uint32_t CMsgSteamDatagramClientPingSampleReply_POP::_internal_test_dc_score() const {
  return _impl_.test_dc_score_;
}
inline uint32_t CMsgSteamDatagramClientPingSampleReply_POP::test_dc_score() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramClientPingSampleReply.POP.test_dc_score)
  return _internal_test_dc_score();
}
inline void CMsgSteamDatagramClientPingSampleReply_POP::_internal_set_test_dc_score(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00002000u;
  _impl_.test_dc_score_ = value;
}
inline void CMsgSteamDatagramClientPingSampleReply_POP::set_test_dc_score(uint32_t value) {
  _internal_set_test_dc_score(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramClientPingSampleReply.POP.test_dc_score)
}

// optional fixed32 test_dc_via_relay_pop_id = 17;
inline bool CMsgSteamDatagramClientPingSampleReply_POP::_internal_has_test_dc_via_relay_pop_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0;
  return value;
}
inline bool CMsgSteamDatagramClientPingSampleReply_POP::has_test_dc_via_relay_pop_id() const {
  return _internal_has_test_dc_via_relay_pop_id();
}
inline void CMsgSteamDatagramClientPingSampleReply_POP::clear_test_dc_via_relay_pop_id() {
  _impl_.test_dc_via_relay_pop_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00004000u;
}
inline uint32_t CMsgSteamDatagramClientPingSampleReply_POP::_internal_test_dc_via_relay_pop_id() const {
  return _impl_.test_dc_via_relay_pop_id_;
}
inline uint32_t CMsgSteamDatagramClientPingSampleReply_POP::test_dc_via_relay_pop_id() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramClientPingSampleReply.POP.test_dc_via_relay_pop_id)
  return _internal_test_dc_via_relay_pop_id();
}
inline void CMsgSteamDatagramClientPingSampleReply_POP::_internal_set_test_dc_via_relay_pop_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00004000u;
  _impl_.test_dc_via_relay_pop_id_ = value;
}
inline void CMsgSteamDatagramClientPingSampleReply_POP::set_test_dc_via_relay_pop_id(uint32_t value) {
  _internal_set_test_dc_via_relay_pop_id(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramClientPingSampleReply.POP.test_dc_via_relay_pop_id)
}

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

// CMsgSteamDatagramClientPingSampleReply_LegacyDataCenter

// optional fixed32 data_center_id = 1;
inline bool CMsgSteamDatagramClientPingSampleReply_LegacyDataCenter::_internal_has_data_center_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgSteamDatagramClientPingSampleReply_LegacyDataCenter::has_data_center_id() const {
  return _internal_has_data_center_id();
}
inline void CMsgSteamDatagramClientPingSampleReply_LegacyDataCenter::clear_data_center_id() {
  _impl_.data_center_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t CMsgSteamDatagramClientPingSampleReply_LegacyDataCenter::_internal_data_center_id() const {
  return _impl_.data_center_id_;
}
inline uint32_t CMsgSteamDatagramClientPingSampleReply_LegacyDataCenter::data_center_id() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramClientPingSampleReply.LegacyDataCenter.data_center_id)
  return _internal_data_center_id();
}
inline void CMsgSteamDatagramClientPingSampleReply_LegacyDataCenter::_internal_set_data_center_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.data_center_id_ = value;
}
inline void CMsgSteamDatagramClientPingSampleReply_LegacyDataCenter::set_data_center_id(uint32_t value) {
  _internal_set_data_center_id(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramClientPingSampleReply.LegacyDataCenter.data_center_id)
}

// optional fixed32 best_dc_via_relay_pop_id = 2;
inline bool CMsgSteamDatagramClientPingSampleReply_LegacyDataCenter::_internal_has_best_dc_via_relay_pop_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgSteamDatagramClientPingSampleReply_LegacyDataCenter::has_best_dc_via_relay_pop_id() const {
  return _internal_has_best_dc_via_relay_pop_id();
}
inline void CMsgSteamDatagramClientPingSampleReply_LegacyDataCenter::clear_best_dc_via_relay_pop_id() {
  _impl_.best_dc_via_relay_pop_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t CMsgSteamDatagramClientPingSampleReply_LegacyDataCenter::_internal_best_dc_via_relay_pop_id() const {
  return _impl_.best_dc_via_relay_pop_id_;
}
inline uint32_t CMsgSteamDatagramClientPingSampleReply_LegacyDataCenter::best_dc_via_relay_pop_id() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramClientPingSampleReply.LegacyDataCenter.best_dc_via_relay_pop_id)
  return _internal_best_dc_via_relay_pop_id();
}
inline void CMsgSteamDatagramClientPingSampleReply_LegacyDataCenter::_internal_set_best_dc_via_relay_pop_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.best_dc_via_relay_pop_id_ = value;
}
inline void CMsgSteamDatagramClientPingSampleReply_LegacyDataCenter::set_best_dc_via_relay_pop_id(uint32_t value) {
  _internal_set_best_dc_via_relay_pop_id(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramClientPingSampleReply.LegacyDataCenter.best_dc_via_relay_pop_id)
}

// optional uint32 best_dc_ping_ms = 3;
inline bool CMsgSteamDatagramClientPingSampleReply_LegacyDataCenter::_internal_has_best_dc_ping_ms() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgSteamDatagramClientPingSampleReply_LegacyDataCenter::has_best_dc_ping_ms() const {
  return _internal_has_best_dc_ping_ms();
}
inline void CMsgSteamDatagramClientPingSampleReply_LegacyDataCenter::clear_best_dc_ping_ms() {
  _impl_.best_dc_ping_ms_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t CMsgSteamDatagramClientPingSampleReply_LegacyDataCenter::_internal_best_dc_ping_ms() const {
  return _impl_.best_dc_ping_ms_;
}
inline uint32_t CMsgSteamDatagramClientPingSampleReply_LegacyDataCenter::best_dc_ping_ms() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramClientPingSampleReply.LegacyDataCenter.best_dc_ping_ms)
  return _internal_best_dc_ping_ms();
}
inline void CMsgSteamDatagramClientPingSampleReply_LegacyDataCenter::_internal_set_best_dc_ping_ms(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.best_dc_ping_ms_ = value;
}
inline void CMsgSteamDatagramClientPingSampleReply_LegacyDataCenter::set_best_dc_ping_ms(uint32_t value) {
  _internal_set_best_dc_ping_ms(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramClientPingSampleReply.LegacyDataCenter.best_dc_ping_ms)
}

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

// CMsgSteamDatagramClientPingSampleReply

// optional fixed32 connection_id = 1;
inline bool CMsgSteamDatagramClientPingSampleReply::_internal_has_connection_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgSteamDatagramClientPingSampleReply::has_connection_id() const {
  return _internal_has_connection_id();
}
inline void CMsgSteamDatagramClientPingSampleReply::clear_connection_id() {
  _impl_.connection_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t CMsgSteamDatagramClientPingSampleReply::_internal_connection_id() const {
  return _impl_.connection_id_;
}
inline uint32_t CMsgSteamDatagramClientPingSampleReply::connection_id() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramClientPingSampleReply.connection_id)
  return _internal_connection_id();
}
inline void CMsgSteamDatagramClientPingSampleReply::_internal_set_connection_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.connection_id_ = value;
}
inline void CMsgSteamDatagramClientPingSampleReply::set_connection_id(uint32_t value) {
  _internal_set_connection_id(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramClientPingSampleReply.connection_id)
}

// optional bool relay_override_active = 5;
inline bool CMsgSteamDatagramClientPingSampleReply::_internal_has_relay_override_active() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgSteamDatagramClientPingSampleReply::has_relay_override_active() const {
  return _internal_has_relay_override_active();
}
inline void CMsgSteamDatagramClientPingSampleReply::clear_relay_override_active() {
  _impl_.relay_override_active_ = false;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline bool CMsgSteamDatagramClientPingSampleReply::_internal_relay_override_active() const {
  return _impl_.relay_override_active_;
}
inline bool CMsgSteamDatagramClientPingSampleReply::relay_override_active() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramClientPingSampleReply.relay_override_active)
  return _internal_relay_override_active();
}
inline void CMsgSteamDatagramClientPingSampleReply::_internal_set_relay_override_active(bool value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.relay_override_active_ = value;
}
inline void CMsgSteamDatagramClientPingSampleReply::set_relay_override_active(bool value) {
  _internal_set_relay_override_active(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramClientPingSampleReply.relay_override_active)
}

// optional .CMsgTOSTreatment tos = 6;
inline bool CMsgSteamDatagramClientPingSampleReply::_internal_has_tos() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.tos_ != nullptr);
  return value;
}
inline bool CMsgSteamDatagramClientPingSampleReply::has_tos() const {
  return _internal_has_tos();
}
inline void CMsgSteamDatagramClientPingSampleReply::clear_tos() {
  if (_impl_.tos_ != nullptr) _impl_.tos_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const ::CMsgTOSTreatment& CMsgSteamDatagramClientPingSampleReply::_internal_tos() const {
  const ::CMsgTOSTreatment* p = _impl_.tos_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgTOSTreatment&>(
      ::_CMsgTOSTreatment_default_instance_);
}
inline const ::CMsgTOSTreatment& CMsgSteamDatagramClientPingSampleReply::tos() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramClientPingSampleReply.tos)
  return _internal_tos();
}
inline void CMsgSteamDatagramClientPingSampleReply::unsafe_arena_set_allocated_tos(
    ::CMsgTOSTreatment* tos) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.tos_);
  }
  _impl_.tos_ = tos;
  if (tos) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgSteamDatagramClientPingSampleReply.tos)
}
inline ::CMsgTOSTreatment* CMsgSteamDatagramClientPingSampleReply::release_tos() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgTOSTreatment* temp = _impl_.tos_;
  _impl_.tos_ = 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 ::CMsgTOSTreatment* CMsgSteamDatagramClientPingSampleReply::unsafe_arena_release_tos() {
  // @@protoc_insertion_point(field_release:CMsgSteamDatagramClientPingSampleReply.tos)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgTOSTreatment* temp = _impl_.tos_;
  _impl_.tos_ = nullptr;
  return temp;
}
inline ::CMsgTOSTreatment* CMsgSteamDatagramClientPingSampleReply::_internal_mutable_tos() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.tos_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgTOSTreatment>(GetArenaForAllocation());
    _impl_.tos_ = p;
  }
  return _impl_.tos_;
}
inline ::CMsgTOSTreatment* CMsgSteamDatagramClientPingSampleReply::mutable_tos() {
  ::CMsgTOSTreatment* _msg = _internal_mutable_tos();
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramClientPingSampleReply.tos)
  return _msg;
}
inline void CMsgSteamDatagramClientPingSampleReply::set_allocated_tos(::CMsgTOSTreatment* tos) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.tos_;
  }
  if (tos) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(tos);
    if (message_arena != submessage_arena) {
      tos = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, tos, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.tos_ = tos;
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamDatagramClientPingSampleReply.tos)
}

// repeated .CMsgSteamDatagramClientPingSampleReply.POP pops = 2;
inline int CMsgSteamDatagramClientPingSampleReply::_internal_pops_size() const {
  return _impl_.pops_.size();
}
inline int CMsgSteamDatagramClientPingSampleReply::pops_size() const {
  return _internal_pops_size();
}
inline void CMsgSteamDatagramClientPingSampleReply::clear_pops() {
  _impl_.pops_.Clear();
}
inline ::CMsgSteamDatagramClientPingSampleReply_POP* CMsgSteamDatagramClientPingSampleReply::mutable_pops(int index) {
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramClientPingSampleReply.pops)
  return _impl_.pops_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgSteamDatagramClientPingSampleReply_POP >*
CMsgSteamDatagramClientPingSampleReply::mutable_pops() {
  // @@protoc_insertion_point(field_mutable_list:CMsgSteamDatagramClientPingSampleReply.pops)
  return &_impl_.pops_;
}
inline const ::CMsgSteamDatagramClientPingSampleReply_POP& CMsgSteamDatagramClientPingSampleReply::_internal_pops(int index) const {
  return _impl_.pops_.Get(index);
}
inline const ::CMsgSteamDatagramClientPingSampleReply_POP& CMsgSteamDatagramClientPingSampleReply::pops(int index) const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramClientPingSampleReply.pops)
  return _internal_pops(index);
}
inline ::CMsgSteamDatagramClientPingSampleReply_POP* CMsgSteamDatagramClientPingSampleReply::_internal_add_pops() {
  return _impl_.pops_.Add();
}
inline ::CMsgSteamDatagramClientPingSampleReply_POP* CMsgSteamDatagramClientPingSampleReply::add_pops() {
  ::CMsgSteamDatagramClientPingSampleReply_POP* _add = _internal_add_pops();
  // @@protoc_insertion_point(field_add:CMsgSteamDatagramClientPingSampleReply.pops)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgSteamDatagramClientPingSampleReply_POP >&
CMsgSteamDatagramClientPingSampleReply::pops() const {
  // @@protoc_insertion_point(field_list:CMsgSteamDatagramClientPingSampleReply.pops)
  return _impl_.pops_;
}

// repeated .CMsgSteamDatagramClientPingSampleReply.LegacyDataCenter legacy_data_centers = 3;
inline int CMsgSteamDatagramClientPingSampleReply::_internal_legacy_data_centers_size() const {
  return _impl_.legacy_data_centers_.size();
}
inline int CMsgSteamDatagramClientPingSampleReply::legacy_data_centers_size() const {
  return _internal_legacy_data_centers_size();
}
inline void CMsgSteamDatagramClientPingSampleReply::clear_legacy_data_centers() {
  _impl_.legacy_data_centers_.Clear();
}
inline ::CMsgSteamDatagramClientPingSampleReply_LegacyDataCenter* CMsgSteamDatagramClientPingSampleReply::mutable_legacy_data_centers(int index) {
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramClientPingSampleReply.legacy_data_centers)
  return _impl_.legacy_data_centers_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgSteamDatagramClientPingSampleReply_LegacyDataCenter >*
CMsgSteamDatagramClientPingSampleReply::mutable_legacy_data_centers() {
  // @@protoc_insertion_point(field_mutable_list:CMsgSteamDatagramClientPingSampleReply.legacy_data_centers)
  return &_impl_.legacy_data_centers_;
}
inline const ::CMsgSteamDatagramClientPingSampleReply_LegacyDataCenter& CMsgSteamDatagramClientPingSampleReply::_internal_legacy_data_centers(int index) const {
  return _impl_.legacy_data_centers_.Get(index);
}
inline const ::CMsgSteamDatagramClientPingSampleReply_LegacyDataCenter& CMsgSteamDatagramClientPingSampleReply::legacy_data_centers(int index) const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramClientPingSampleReply.legacy_data_centers)
  return _internal_legacy_data_centers(index);
}
inline ::CMsgSteamDatagramClientPingSampleReply_LegacyDataCenter* CMsgSteamDatagramClientPingSampleReply::_internal_add_legacy_data_centers() {
  return _impl_.legacy_data_centers_.Add();
}
inline ::CMsgSteamDatagramClientPingSampleReply_LegacyDataCenter* CMsgSteamDatagramClientPingSampleReply::add_legacy_data_centers() {
  ::CMsgSteamDatagramClientPingSampleReply_LegacyDataCenter* _add = _internal_add_legacy_data_centers();
  // @@protoc_insertion_point(field_add:CMsgSteamDatagramClientPingSampleReply.legacy_data_centers)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgSteamDatagramClientPingSampleReply_LegacyDataCenter >&
CMsgSteamDatagramClientPingSampleReply::legacy_data_centers() const {
  // @@protoc_insertion_point(field_list:CMsgSteamDatagramClientPingSampleReply.legacy_data_centers)
  return _impl_.legacy_data_centers_;
}

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

// CMsgSteamDatagramClientSwitchedPrimary_RouterQuality

// optional uint32 score = 1;
inline bool CMsgSteamDatagramClientSwitchedPrimary_RouterQuality::_internal_has_score() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgSteamDatagramClientSwitchedPrimary_RouterQuality::has_score() const {
  return _internal_has_score();
}
inline void CMsgSteamDatagramClientSwitchedPrimary_RouterQuality::clear_score() {
  _impl_.score_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t CMsgSteamDatagramClientSwitchedPrimary_RouterQuality::_internal_score() const {
  return _impl_.score_;
}
inline uint32_t CMsgSteamDatagramClientSwitchedPrimary_RouterQuality::score() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramClientSwitchedPrimary.RouterQuality.score)
  return _internal_score();
}
inline void CMsgSteamDatagramClientSwitchedPrimary_RouterQuality::_internal_set_score(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.score_ = value;
}
inline void CMsgSteamDatagramClientSwitchedPrimary_RouterQuality::set_score(uint32_t value) {
  _internal_set_score(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramClientSwitchedPrimary.RouterQuality.score)
}

// optional uint32 front_ping = 2;
inline bool CMsgSteamDatagramClientSwitchedPrimary_RouterQuality::_internal_has_front_ping() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgSteamDatagramClientSwitchedPrimary_RouterQuality::has_front_ping() const {
  return _internal_has_front_ping();
}
inline void CMsgSteamDatagramClientSwitchedPrimary_RouterQuality::clear_front_ping() {
  _impl_.front_ping_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t CMsgSteamDatagramClientSwitchedPrimary_RouterQuality::_internal_front_ping() const {
  return _impl_.front_ping_;
}
inline uint32_t CMsgSteamDatagramClientSwitchedPrimary_RouterQuality::front_ping() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramClientSwitchedPrimary.RouterQuality.front_ping)
  return _internal_front_ping();
}
inline void CMsgSteamDatagramClientSwitchedPrimary_RouterQuality::_internal_set_front_ping(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.front_ping_ = value;
}
inline void CMsgSteamDatagramClientSwitchedPrimary_RouterQuality::set_front_ping(uint32_t value) {
  _internal_set_front_ping(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramClientSwitchedPrimary.RouterQuality.front_ping)
}

// optional uint32 back_ping = 3;
inline bool CMsgSteamDatagramClientSwitchedPrimary_RouterQuality::_internal_has_back_ping() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgSteamDatagramClientSwitchedPrimary_RouterQuality::has_back_ping() const {
  return _internal_has_back_ping();
}
inline void CMsgSteamDatagramClientSwitchedPrimary_RouterQuality::clear_back_ping() {
  _impl_.back_ping_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t CMsgSteamDatagramClientSwitchedPrimary_RouterQuality::_internal_back_ping() const {
  return _impl_.back_ping_;
}
inline uint32_t CMsgSteamDatagramClientSwitchedPrimary_RouterQuality::back_ping() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramClientSwitchedPrimary.RouterQuality.back_ping)
  return _internal_back_ping();
}
inline void CMsgSteamDatagramClientSwitchedPrimary_RouterQuality::_internal_set_back_ping(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.back_ping_ = value;
}
inline void CMsgSteamDatagramClientSwitchedPrimary_RouterQuality::set_back_ping(uint32_t value) {
  _internal_set_back_ping(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramClientSwitchedPrimary.RouterQuality.back_ping)
}

// optional uint32 seconds_until_down = 4;
inline bool CMsgSteamDatagramClientSwitchedPrimary_RouterQuality::_internal_has_seconds_until_down() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CMsgSteamDatagramClientSwitchedPrimary_RouterQuality::has_seconds_until_down() const {
  return _internal_has_seconds_until_down();
}
inline void CMsgSteamDatagramClientSwitchedPrimary_RouterQuality::clear_seconds_until_down() {
  _impl_.seconds_until_down_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t CMsgSteamDatagramClientSwitchedPrimary_RouterQuality::_internal_seconds_until_down() const {
  return _impl_.seconds_until_down_;
}
inline uint32_t CMsgSteamDatagramClientSwitchedPrimary_RouterQuality::seconds_until_down() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramClientSwitchedPrimary.RouterQuality.seconds_until_down)
  return _internal_seconds_until_down();
}
inline void CMsgSteamDatagramClientSwitchedPrimary_RouterQuality::_internal_set_seconds_until_down(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.seconds_until_down_ = value;
}
inline void CMsgSteamDatagramClientSwitchedPrimary_RouterQuality::set_seconds_until_down(uint32_t value) {
  _internal_set_seconds_until_down(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramClientSwitchedPrimary.RouterQuality.seconds_until_down)
}

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

// CMsgSteamDatagramClientSwitchedPrimary

// optional fixed32 connection_id = 1;
inline bool CMsgSteamDatagramClientSwitchedPrimary::_internal_has_connection_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool CMsgSteamDatagramClientSwitchedPrimary::has_connection_id() const {
  return _internal_has_connection_id();
}
inline void CMsgSteamDatagramClientSwitchedPrimary::clear_connection_id() {
  _impl_.connection_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline uint32_t CMsgSteamDatagramClientSwitchedPrimary::_internal_connection_id() const {
  return _impl_.connection_id_;
}
inline uint32_t CMsgSteamDatagramClientSwitchedPrimary::connection_id() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramClientSwitchedPrimary.connection_id)
  return _internal_connection_id();
}
inline void CMsgSteamDatagramClientSwitchedPrimary::_internal_set_connection_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.connection_id_ = value;
}
inline void CMsgSteamDatagramClientSwitchedPrimary::set_connection_id(uint32_t value) {
  _internal_set_connection_id(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramClientSwitchedPrimary.connection_id)
}

// optional fixed32 from_ip = 2;
inline bool CMsgSteamDatagramClientSwitchedPrimary::_internal_has_from_ip() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool CMsgSteamDatagramClientSwitchedPrimary::has_from_ip() const {
  return _internal_has_from_ip();
}
inline void CMsgSteamDatagramClientSwitchedPrimary::clear_from_ip() {
  _impl_.from_ip_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline uint32_t CMsgSteamDatagramClientSwitchedPrimary::_internal_from_ip() const {
  return _impl_.from_ip_;
}
inline uint32_t CMsgSteamDatagramClientSwitchedPrimary::from_ip() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramClientSwitchedPrimary.from_ip)
  return _internal_from_ip();
}
inline void CMsgSteamDatagramClientSwitchedPrimary::_internal_set_from_ip(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.from_ip_ = value;
}
inline void CMsgSteamDatagramClientSwitchedPrimary::set_from_ip(uint32_t value) {
  _internal_set_from_ip(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramClientSwitchedPrimary.from_ip)
}

// optional uint32 from_port = 3;
inline bool CMsgSteamDatagramClientSwitchedPrimary::_internal_has_from_port() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool CMsgSteamDatagramClientSwitchedPrimary::has_from_port() const {
  return _internal_has_from_port();
}
inline void CMsgSteamDatagramClientSwitchedPrimary::clear_from_port() {
  _impl_.from_port_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline uint32_t CMsgSteamDatagramClientSwitchedPrimary::_internal_from_port() const {
  return _impl_.from_port_;
}
inline uint32_t CMsgSteamDatagramClientSwitchedPrimary::from_port() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramClientSwitchedPrimary.from_port)
  return _internal_from_port();
}
inline void CMsgSteamDatagramClientSwitchedPrimary::_internal_set_from_port(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.from_port_ = value;
}
inline void CMsgSteamDatagramClientSwitchedPrimary::set_from_port(uint32_t value) {
  _internal_set_from_port(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramClientSwitchedPrimary.from_port)
}

// optional fixed32 from_router_cluster = 4;
inline bool CMsgSteamDatagramClientSwitchedPrimary::_internal_has_from_router_cluster() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool CMsgSteamDatagramClientSwitchedPrimary::has_from_router_cluster() const {
  return _internal_has_from_router_cluster();
}
inline void CMsgSteamDatagramClientSwitchedPrimary::clear_from_router_cluster() {
  _impl_.from_router_cluster_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline uint32_t CMsgSteamDatagramClientSwitchedPrimary::_internal_from_router_cluster() const {
  return _impl_.from_router_cluster_;
}
inline uint32_t CMsgSteamDatagramClientSwitchedPrimary::from_router_cluster() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramClientSwitchedPrimary.from_router_cluster)
  return _internal_from_router_cluster();
}
inline void CMsgSteamDatagramClientSwitchedPrimary::_internal_set_from_router_cluster(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.from_router_cluster_ = value;
}
inline void CMsgSteamDatagramClientSwitchedPrimary::set_from_router_cluster(uint32_t value) {
  _internal_set_from_router_cluster(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramClientSwitchedPrimary.from_router_cluster)
}

// optional uint32 from_active_time = 5;
inline bool CMsgSteamDatagramClientSwitchedPrimary::_internal_has_from_active_time() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool CMsgSteamDatagramClientSwitchedPrimary::has_from_active_time() const {
  return _internal_has_from_active_time();
}
inline void CMsgSteamDatagramClientSwitchedPrimary::clear_from_active_time() {
  _impl_.from_active_time_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline uint32_t CMsgSteamDatagramClientSwitchedPrimary::_internal_from_active_time() const {
  return _impl_.from_active_time_;
}
inline uint32_t CMsgSteamDatagramClientSwitchedPrimary::from_active_time() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramClientSwitchedPrimary.from_active_time)
  return _internal_from_active_time();
}
inline void CMsgSteamDatagramClientSwitchedPrimary::_internal_set_from_active_time(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.from_active_time_ = value;
}
inline void CMsgSteamDatagramClientSwitchedPrimary::set_from_active_time(uint32_t value) {
  _internal_set_from_active_time(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramClientSwitchedPrimary.from_active_time)
}

// optional uint32 from_active_packets_recv = 6;
inline bool CMsgSteamDatagramClientSwitchedPrimary::_internal_has_from_active_packets_recv() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool CMsgSteamDatagramClientSwitchedPrimary::has_from_active_packets_recv() const {
  return _internal_has_from_active_packets_recv();
}
inline void CMsgSteamDatagramClientSwitchedPrimary::clear_from_active_packets_recv() {
  _impl_.from_active_packets_recv_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline uint32_t CMsgSteamDatagramClientSwitchedPrimary::_internal_from_active_packets_recv() const {
  return _impl_.from_active_packets_recv_;
}
inline uint32_t CMsgSteamDatagramClientSwitchedPrimary::from_active_packets_recv() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramClientSwitchedPrimary.from_active_packets_recv)
  return _internal_from_active_packets_recv();
}
inline void CMsgSteamDatagramClientSwitchedPrimary::_internal_set_from_active_packets_recv(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000400u;
  _impl_.from_active_packets_recv_ = value;
}
inline void CMsgSteamDatagramClientSwitchedPrimary::set_from_active_packets_recv(uint32_t value) {
  _internal_set_from_active_packets_recv(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramClientSwitchedPrimary.from_active_packets_recv)
}

// optional string from_dropped_reason = 7;
inline bool CMsgSteamDatagramClientSwitchedPrimary::_internal_has_from_dropped_reason() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgSteamDatagramClientSwitchedPrimary::has_from_dropped_reason() const {
  return _internal_has_from_dropped_reason();
}
inline void CMsgSteamDatagramClientSwitchedPrimary::clear_from_dropped_reason() {
  _impl_.from_dropped_reason_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CMsgSteamDatagramClientSwitchedPrimary::from_dropped_reason() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramClientSwitchedPrimary.from_dropped_reason)
  return _internal_from_dropped_reason();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgSteamDatagramClientSwitchedPrimary::set_from_dropped_reason(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.from_dropped_reason_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramClientSwitchedPrimary.from_dropped_reason)
}
inline std::string* CMsgSteamDatagramClientSwitchedPrimary::mutable_from_dropped_reason() {
  std::string* _s = _internal_mutable_from_dropped_reason();
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramClientSwitchedPrimary.from_dropped_reason)
  return _s;
}
inline const std::string& CMsgSteamDatagramClientSwitchedPrimary::_internal_from_dropped_reason() const {
  return _impl_.from_dropped_reason_.Get();
}
inline void CMsgSteamDatagramClientSwitchedPrimary::_internal_set_from_dropped_reason(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.from_dropped_reason_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramClientSwitchedPrimary::_internal_mutable_from_dropped_reason() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.from_dropped_reason_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramClientSwitchedPrimary::release_from_dropped_reason() {
  // @@protoc_insertion_point(field_release:CMsgSteamDatagramClientSwitchedPrimary.from_dropped_reason)
  if (!_internal_has_from_dropped_reason()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.from_dropped_reason_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.from_dropped_reason_.IsDefault()) {
    _impl_.from_dropped_reason_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgSteamDatagramClientSwitchedPrimary::set_allocated_from_dropped_reason(std::string* from_dropped_reason) {
  if (from_dropped_reason != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.from_dropped_reason_.SetAllocated(from_dropped_reason, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.from_dropped_reason_.IsDefault()) {
    _impl_.from_dropped_reason_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamDatagramClientSwitchedPrimary.from_dropped_reason)
}

// optional uint32 gap_ms = 8;
inline bool CMsgSteamDatagramClientSwitchedPrimary::_internal_has_gap_ms() const {
  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
  return value;
}
inline bool CMsgSteamDatagramClientSwitchedPrimary::has_gap_ms() const {
  return _internal_has_gap_ms();
}
inline void CMsgSteamDatagramClientSwitchedPrimary::clear_gap_ms() {
  _impl_.gap_ms_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000800u;
}
inline uint32_t CMsgSteamDatagramClientSwitchedPrimary::_internal_gap_ms() const {
  return _impl_.gap_ms_;
}
inline uint32_t CMsgSteamDatagramClientSwitchedPrimary::gap_ms() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramClientSwitchedPrimary.gap_ms)
  return _internal_gap_ms();
}
inline void CMsgSteamDatagramClientSwitchedPrimary::_internal_set_gap_ms(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000800u;
  _impl_.gap_ms_ = value;
}
inline void CMsgSteamDatagramClientSwitchedPrimary::set_gap_ms(uint32_t value) {
  _internal_set_gap_ms(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramClientSwitchedPrimary.gap_ms)
}

// optional .CMsgSteamDatagramClientSwitchedPrimary.RouterQuality from_quality_now = 9;
inline bool CMsgSteamDatagramClientSwitchedPrimary::_internal_has_from_quality_now() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.from_quality_now_ != nullptr);
  return value;
}
inline bool CMsgSteamDatagramClientSwitchedPrimary::has_from_quality_now() const {
  return _internal_has_from_quality_now();
}
inline void CMsgSteamDatagramClientSwitchedPrimary::clear_from_quality_now() {
  if (_impl_.from_quality_now_ != nullptr) _impl_.from_quality_now_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality& CMsgSteamDatagramClientSwitchedPrimary::_internal_from_quality_now() const {
  const ::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality* p = _impl_.from_quality_now_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality&>(
      ::_CMsgSteamDatagramClientSwitchedPrimary_RouterQuality_default_instance_);
}
inline const ::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality& CMsgSteamDatagramClientSwitchedPrimary::from_quality_now() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramClientSwitchedPrimary.from_quality_now)
  return _internal_from_quality_now();
}
inline void CMsgSteamDatagramClientSwitchedPrimary::unsafe_arena_set_allocated_from_quality_now(
    ::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality* from_quality_now) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.from_quality_now_);
  }
  _impl_.from_quality_now_ = from_quality_now;
  if (from_quality_now) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgSteamDatagramClientSwitchedPrimary.from_quality_now)
}
inline ::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality* CMsgSteamDatagramClientSwitchedPrimary::release_from_quality_now() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality* temp = _impl_.from_quality_now_;
  _impl_.from_quality_now_ = 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 ::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality* CMsgSteamDatagramClientSwitchedPrimary::unsafe_arena_release_from_quality_now() {
  // @@protoc_insertion_point(field_release:CMsgSteamDatagramClientSwitchedPrimary.from_quality_now)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality* temp = _impl_.from_quality_now_;
  _impl_.from_quality_now_ = nullptr;
  return temp;
}
inline ::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality* CMsgSteamDatagramClientSwitchedPrimary::_internal_mutable_from_quality_now() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.from_quality_now_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality>(GetArenaForAllocation());
    _impl_.from_quality_now_ = p;
  }
  return _impl_.from_quality_now_;
}
inline ::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality* CMsgSteamDatagramClientSwitchedPrimary::mutable_from_quality_now() {
  ::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality* _msg = _internal_mutable_from_quality_now();
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramClientSwitchedPrimary.from_quality_now)
  return _msg;
}
inline void CMsgSteamDatagramClientSwitchedPrimary::set_allocated_from_quality_now(::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality* from_quality_now) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.from_quality_now_;
  }
  if (from_quality_now) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(from_quality_now);
    if (message_arena != submessage_arena) {
      from_quality_now = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, from_quality_now, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.from_quality_now_ = from_quality_now;
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamDatagramClientSwitchedPrimary.from_quality_now)
}

// optional .CMsgSteamDatagramClientSwitchedPrimary.RouterQuality to_quality_now = 10;
inline bool CMsgSteamDatagramClientSwitchedPrimary::_internal_has_to_quality_now() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.to_quality_now_ != nullptr);
  return value;
}
inline bool CMsgSteamDatagramClientSwitchedPrimary::has_to_quality_now() const {
  return _internal_has_to_quality_now();
}
inline void CMsgSteamDatagramClientSwitchedPrimary::clear_to_quality_now() {
  if (_impl_.to_quality_now_ != nullptr) _impl_.to_quality_now_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const ::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality& CMsgSteamDatagramClientSwitchedPrimary::_internal_to_quality_now() const {
  const ::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality* p = _impl_.to_quality_now_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality&>(
      ::_CMsgSteamDatagramClientSwitchedPrimary_RouterQuality_default_instance_);
}
inline const ::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality& CMsgSteamDatagramClientSwitchedPrimary::to_quality_now() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramClientSwitchedPrimary.to_quality_now)
  return _internal_to_quality_now();
}
inline void CMsgSteamDatagramClientSwitchedPrimary::unsafe_arena_set_allocated_to_quality_now(
    ::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality* to_quality_now) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.to_quality_now_);
  }
  _impl_.to_quality_now_ = to_quality_now;
  if (to_quality_now) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgSteamDatagramClientSwitchedPrimary.to_quality_now)
}
inline ::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality* CMsgSteamDatagramClientSwitchedPrimary::release_to_quality_now() {
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality* temp = _impl_.to_quality_now_;
  _impl_.to_quality_now_ = 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 ::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality* CMsgSteamDatagramClientSwitchedPrimary::unsafe_arena_release_to_quality_now() {
  // @@protoc_insertion_point(field_release:CMsgSteamDatagramClientSwitchedPrimary.to_quality_now)
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality* temp = _impl_.to_quality_now_;
  _impl_.to_quality_now_ = nullptr;
  return temp;
}
inline ::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality* CMsgSteamDatagramClientSwitchedPrimary::_internal_mutable_to_quality_now() {
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.to_quality_now_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality>(GetArenaForAllocation());
    _impl_.to_quality_now_ = p;
  }
  return _impl_.to_quality_now_;
}
inline ::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality* CMsgSteamDatagramClientSwitchedPrimary::mutable_to_quality_now() {
  ::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality* _msg = _internal_mutable_to_quality_now();
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramClientSwitchedPrimary.to_quality_now)
  return _msg;
}
inline void CMsgSteamDatagramClientSwitchedPrimary::set_allocated_to_quality_now(::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality* to_quality_now) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.to_quality_now_;
  }
  if (to_quality_now) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(to_quality_now);
    if (message_arena != submessage_arena) {
      to_quality_now = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, to_quality_now, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.to_quality_now_ = to_quality_now;
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamDatagramClientSwitchedPrimary.to_quality_now)
}

// optional .CMsgSteamDatagramClientSwitchedPrimary.RouterQuality from_quality_then = 11;
inline bool CMsgSteamDatagramClientSwitchedPrimary::_internal_has_from_quality_then() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.from_quality_then_ != nullptr);
  return value;
}
inline bool CMsgSteamDatagramClientSwitchedPrimary::has_from_quality_then() const {
  return _internal_has_from_quality_then();
}
inline void CMsgSteamDatagramClientSwitchedPrimary::clear_from_quality_then() {
  if (_impl_.from_quality_then_ != nullptr) _impl_.from_quality_then_->Clear();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const ::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality& CMsgSteamDatagramClientSwitchedPrimary::_internal_from_quality_then() const {
  const ::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality* p = _impl_.from_quality_then_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality&>(
      ::_CMsgSteamDatagramClientSwitchedPrimary_RouterQuality_default_instance_);
}
inline const ::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality& CMsgSteamDatagramClientSwitchedPrimary::from_quality_then() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramClientSwitchedPrimary.from_quality_then)
  return _internal_from_quality_then();
}
inline void CMsgSteamDatagramClientSwitchedPrimary::unsafe_arena_set_allocated_from_quality_then(
    ::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality* from_quality_then) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.from_quality_then_);
  }
  _impl_.from_quality_then_ = from_quality_then;
  if (from_quality_then) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgSteamDatagramClientSwitchedPrimary.from_quality_then)
}
inline ::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality* CMsgSteamDatagramClientSwitchedPrimary::release_from_quality_then() {
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality* temp = _impl_.from_quality_then_;
  _impl_.from_quality_then_ = 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 ::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality* CMsgSteamDatagramClientSwitchedPrimary::unsafe_arena_release_from_quality_then() {
  // @@protoc_insertion_point(field_release:CMsgSteamDatagramClientSwitchedPrimary.from_quality_then)
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality* temp = _impl_.from_quality_then_;
  _impl_.from_quality_then_ = nullptr;
  return temp;
}
inline ::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality* CMsgSteamDatagramClientSwitchedPrimary::_internal_mutable_from_quality_then() {
  _impl_._has_bits_[0] |= 0x00000008u;
  if (_impl_.from_quality_then_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality>(GetArenaForAllocation());
    _impl_.from_quality_then_ = p;
  }
  return _impl_.from_quality_then_;
}
inline ::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality* CMsgSteamDatagramClientSwitchedPrimary::mutable_from_quality_then() {
  ::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality* _msg = _internal_mutable_from_quality_then();
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramClientSwitchedPrimary.from_quality_then)
  return _msg;
}
inline void CMsgSteamDatagramClientSwitchedPrimary::set_allocated_from_quality_then(::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality* from_quality_then) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.from_quality_then_;
  }
  if (from_quality_then) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(from_quality_then);
    if (message_arena != submessage_arena) {
      from_quality_then = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, from_quality_then, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.from_quality_then_ = from_quality_then;
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamDatagramClientSwitchedPrimary.from_quality_then)
}

// optional .CMsgSteamDatagramClientSwitchedPrimary.RouterQuality to_quality_then = 12;
inline bool CMsgSteamDatagramClientSwitchedPrimary::_internal_has_to_quality_then() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.to_quality_then_ != nullptr);
  return value;
}
inline bool CMsgSteamDatagramClientSwitchedPrimary::has_to_quality_then() const {
  return _internal_has_to_quality_then();
}
inline void CMsgSteamDatagramClientSwitchedPrimary::clear_to_quality_then() {
  if (_impl_.to_quality_then_ != nullptr) _impl_.to_quality_then_->Clear();
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline const ::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality& CMsgSteamDatagramClientSwitchedPrimary::_internal_to_quality_then() const {
  const ::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality* p = _impl_.to_quality_then_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality&>(
      ::_CMsgSteamDatagramClientSwitchedPrimary_RouterQuality_default_instance_);
}
inline const ::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality& CMsgSteamDatagramClientSwitchedPrimary::to_quality_then() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramClientSwitchedPrimary.to_quality_then)
  return _internal_to_quality_then();
}
inline void CMsgSteamDatagramClientSwitchedPrimary::unsafe_arena_set_allocated_to_quality_then(
    ::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality* to_quality_then) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.to_quality_then_);
  }
  _impl_.to_quality_then_ = to_quality_then;
  if (to_quality_then) {
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgSteamDatagramClientSwitchedPrimary.to_quality_then)
}
inline ::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality* CMsgSteamDatagramClientSwitchedPrimary::release_to_quality_then() {
  _impl_._has_bits_[0] &= ~0x00000010u;
  ::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality* temp = _impl_.to_quality_then_;
  _impl_.to_quality_then_ = 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 ::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality* CMsgSteamDatagramClientSwitchedPrimary::unsafe_arena_release_to_quality_then() {
  // @@protoc_insertion_point(field_release:CMsgSteamDatagramClientSwitchedPrimary.to_quality_then)
  _impl_._has_bits_[0] &= ~0x00000010u;
  ::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality* temp = _impl_.to_quality_then_;
  _impl_.to_quality_then_ = nullptr;
  return temp;
}
inline ::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality* CMsgSteamDatagramClientSwitchedPrimary::_internal_mutable_to_quality_then() {
  _impl_._has_bits_[0] |= 0x00000010u;
  if (_impl_.to_quality_then_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality>(GetArenaForAllocation());
    _impl_.to_quality_then_ = p;
  }
  return _impl_.to_quality_then_;
}
inline ::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality* CMsgSteamDatagramClientSwitchedPrimary::mutable_to_quality_then() {
  ::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality* _msg = _internal_mutable_to_quality_then();
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramClientSwitchedPrimary.to_quality_then)
  return _msg;
}
inline void CMsgSteamDatagramClientSwitchedPrimary::set_allocated_to_quality_then(::CMsgSteamDatagramClientSwitchedPrimary_RouterQuality* to_quality_then) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.to_quality_then_;
  }
  if (to_quality_then) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(to_quality_then);
    if (message_arena != submessage_arena) {
      to_quality_then = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, to_quality_then, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  _impl_.to_quality_then_ = to_quality_then;
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamDatagramClientSwitchedPrimary.to_quality_then)
}

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

// CMsgSteamDatagramConnectRequest

// optional fixed32 connection_id = 1;
inline bool CMsgSteamDatagramConnectRequest::_internal_has_connection_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgSteamDatagramConnectRequest::has_connection_id() const {
  return _internal_has_connection_id();
}
inline void CMsgSteamDatagramConnectRequest::clear_connection_id() {
  _impl_.connection_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t CMsgSteamDatagramConnectRequest::_internal_connection_id() const {
  return _impl_.connection_id_;
}
inline uint32_t CMsgSteamDatagramConnectRequest::connection_id() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectRequest.connection_id)
  return _internal_connection_id();
}
inline void CMsgSteamDatagramConnectRequest::_internal_set_connection_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.connection_id_ = value;
}
inline void CMsgSteamDatagramConnectRequest::set_connection_id(uint32_t value) {
  _internal_set_connection_id(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramConnectRequest.connection_id)
}

// optional fixed64 my_timestamp = 4;
inline bool CMsgSteamDatagramConnectRequest::_internal_has_my_timestamp() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool CMsgSteamDatagramConnectRequest::has_my_timestamp() const {
  return _internal_has_my_timestamp();
}
inline void CMsgSteamDatagramConnectRequest::clear_my_timestamp() {
  _impl_.my_timestamp_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline uint64_t CMsgSteamDatagramConnectRequest::_internal_my_timestamp() const {
  return _impl_.my_timestamp_;
}
inline uint64_t CMsgSteamDatagramConnectRequest::my_timestamp() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectRequest.my_timestamp)
  return _internal_my_timestamp();
}
inline void CMsgSteamDatagramConnectRequest::_internal_set_my_timestamp(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.my_timestamp_ = value;
}
inline void CMsgSteamDatagramConnectRequest::set_my_timestamp(uint64_t value) {
  _internal_set_my_timestamp(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramConnectRequest.my_timestamp)
}

// optional uint32 ping_est_ms = 5;
inline bool CMsgSteamDatagramConnectRequest::_internal_has_ping_est_ms() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool CMsgSteamDatagramConnectRequest::has_ping_est_ms() const {
  return _internal_has_ping_est_ms();
}
inline void CMsgSteamDatagramConnectRequest::clear_ping_est_ms() {
  _impl_.ping_est_ms_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline uint32_t CMsgSteamDatagramConnectRequest::_internal_ping_est_ms() const {
  return _impl_.ping_est_ms_;
}
inline uint32_t CMsgSteamDatagramConnectRequest::ping_est_ms() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectRequest.ping_est_ms)
  return _internal_ping_est_ms();
}
inline void CMsgSteamDatagramConnectRequest::_internal_set_ping_est_ms(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.ping_est_ms_ = value;
}
inline void CMsgSteamDatagramConnectRequest::set_ping_est_ms(uint32_t value) {
  _internal_set_ping_est_ms(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramConnectRequest.ping_est_ms)
}

// optional uint32 virtual_port = 9;
inline bool CMsgSteamDatagramConnectRequest::_internal_has_virtual_port() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool CMsgSteamDatagramConnectRequest::has_virtual_port() const {
  return _internal_has_virtual_port();
}
inline void CMsgSteamDatagramConnectRequest::clear_virtual_port() {
  _impl_.virtual_port_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline uint32_t CMsgSteamDatagramConnectRequest::_internal_virtual_port() const {
  return _impl_.virtual_port_;
}
inline uint32_t CMsgSteamDatagramConnectRequest::virtual_port() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectRequest.virtual_port)
  return _internal_virtual_port();
}
inline void CMsgSteamDatagramConnectRequest::_internal_set_virtual_port(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.virtual_port_ = value;
}
inline void CMsgSteamDatagramConnectRequest::set_virtual_port(uint32_t value) {
  _internal_set_virtual_port(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramConnectRequest.virtual_port)
}

// optional uint32 gameserver_relay_session_id = 2;
inline bool CMsgSteamDatagramConnectRequest::_internal_has_gameserver_relay_session_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CMsgSteamDatagramConnectRequest::has_gameserver_relay_session_id() const {
  return _internal_has_gameserver_relay_session_id();
}
inline void CMsgSteamDatagramConnectRequest::clear_gameserver_relay_session_id() {
  _impl_.gameserver_relay_session_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t CMsgSteamDatagramConnectRequest::_internal_gameserver_relay_session_id() const {
  return _impl_.gameserver_relay_session_id_;
}
inline uint32_t CMsgSteamDatagramConnectRequest::gameserver_relay_session_id() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectRequest.gameserver_relay_session_id)
  return _internal_gameserver_relay_session_id();
}
inline void CMsgSteamDatagramConnectRequest::_internal_set_gameserver_relay_session_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.gameserver_relay_session_id_ = value;
}
inline void CMsgSteamDatagramConnectRequest::set_gameserver_relay_session_id(uint32_t value) {
  _internal_set_gameserver_relay_session_id(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramConnectRequest.gameserver_relay_session_id)
}

// optional .CMsgSteamDatagramSessionCryptInfoSigned crypt = 6;
inline bool CMsgSteamDatagramConnectRequest::_internal_has_crypt() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.crypt_ != nullptr);
  return value;
}
inline bool CMsgSteamDatagramConnectRequest::has_crypt() const {
  return _internal_has_crypt();
}
inline const ::CMsgSteamDatagramSessionCryptInfoSigned& CMsgSteamDatagramConnectRequest::_internal_crypt() const {
  const ::CMsgSteamDatagramSessionCryptInfoSigned* p = _impl_.crypt_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgSteamDatagramSessionCryptInfoSigned&>(
      ::_CMsgSteamDatagramSessionCryptInfoSigned_default_instance_);
}
inline const ::CMsgSteamDatagramSessionCryptInfoSigned& CMsgSteamDatagramConnectRequest::crypt() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectRequest.crypt)
  return _internal_crypt();
}
inline void CMsgSteamDatagramConnectRequest::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:CMsgSteamDatagramConnectRequest.crypt)
}
inline ::CMsgSteamDatagramSessionCryptInfoSigned* CMsgSteamDatagramConnectRequest::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* CMsgSteamDatagramConnectRequest::unsafe_arena_release_crypt() {
  // @@protoc_insertion_point(field_release:CMsgSteamDatagramConnectRequest.crypt)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgSteamDatagramSessionCryptInfoSigned* temp = _impl_.crypt_;
  _impl_.crypt_ = nullptr;
  return temp;
}
inline ::CMsgSteamDatagramSessionCryptInfoSigned* CMsgSteamDatagramConnectRequest::_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* CMsgSteamDatagramConnectRequest::mutable_crypt() {
  ::CMsgSteamDatagramSessionCryptInfoSigned* _msg = _internal_mutable_crypt();
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramConnectRequest.crypt)
  return _msg;
}
inline void CMsgSteamDatagramConnectRequest::set_allocated_crypt(::CMsgSteamDatagramSessionCryptInfoSigned* crypt) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.crypt_);
  }
  if (crypt) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(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:CMsgSteamDatagramConnectRequest.crypt)
}

// optional .CMsgSteamDatagramCertificateSigned cert = 7;
inline bool CMsgSteamDatagramConnectRequest::_internal_has_cert() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.cert_ != nullptr);
  return value;
}
inline bool CMsgSteamDatagramConnectRequest::has_cert() const {
  return _internal_has_cert();
}
inline const ::CMsgSteamDatagramCertificateSigned& CMsgSteamDatagramConnectRequest::_internal_cert() const {
  const ::CMsgSteamDatagramCertificateSigned* p = _impl_.cert_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgSteamDatagramCertificateSigned&>(
      ::_CMsgSteamDatagramCertificateSigned_default_instance_);
}
inline const ::CMsgSteamDatagramCertificateSigned& CMsgSteamDatagramConnectRequest::cert() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectRequest.cert)
  return _internal_cert();
}
inline void CMsgSteamDatagramConnectRequest::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:CMsgSteamDatagramConnectRequest.cert)
}
inline ::CMsgSteamDatagramCertificateSigned* CMsgSteamDatagramConnectRequest::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* CMsgSteamDatagramConnectRequest::unsafe_arena_release_cert() {
  // @@protoc_insertion_point(field_release:CMsgSteamDatagramConnectRequest.cert)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgSteamDatagramCertificateSigned* temp = _impl_.cert_;
  _impl_.cert_ = nullptr;
  return temp;
}
inline ::CMsgSteamDatagramCertificateSigned* CMsgSteamDatagramConnectRequest::_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* CMsgSteamDatagramConnectRequest::mutable_cert() {
  ::CMsgSteamDatagramCertificateSigned* _msg = _internal_mutable_cert();
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramConnectRequest.cert)
  return _msg;
}
inline void CMsgSteamDatagramConnectRequest::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:CMsgSteamDatagramConnectRequest.cert)
}

// optional fixed64 routing_secret = 10;
inline bool CMsgSteamDatagramConnectRequest::_internal_has_routing_secret() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool CMsgSteamDatagramConnectRequest::has_routing_secret() const {
  return _internal_has_routing_secret();
}
inline void CMsgSteamDatagramConnectRequest::clear_routing_secret() {
  _impl_.routing_secret_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline uint64_t CMsgSteamDatagramConnectRequest::_internal_routing_secret() const {
  return _impl_.routing_secret_;
}
inline uint64_t CMsgSteamDatagramConnectRequest::routing_secret() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectRequest.routing_secret)
  return _internal_routing_secret();
}
inline void CMsgSteamDatagramConnectRequest::_internal_set_routing_secret(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.routing_secret_ = value;
}
inline void CMsgSteamDatagramConnectRequest::set_routing_secret(uint64_t value) {
  _internal_set_routing_secret(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramConnectRequest.routing_secret)
}

// optional fixed64 legacy_client_steam_id = 3;
inline bool CMsgSteamDatagramConnectRequest::_internal_has_legacy_client_steam_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CMsgSteamDatagramConnectRequest::has_legacy_client_steam_id() const {
  return _internal_has_legacy_client_steam_id();
}
inline void CMsgSteamDatagramConnectRequest::clear_legacy_client_steam_id() {
  _impl_.legacy_client_steam_id_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline uint64_t CMsgSteamDatagramConnectRequest::_internal_legacy_client_steam_id() const {
  return _impl_.legacy_client_steam_id_;
}
inline uint64_t CMsgSteamDatagramConnectRequest::legacy_client_steam_id() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectRequest.legacy_client_steam_id)
  return _internal_legacy_client_steam_id();
}
inline void CMsgSteamDatagramConnectRequest::_internal_set_legacy_client_steam_id(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.legacy_client_steam_id_ = value;
}
inline void CMsgSteamDatagramConnectRequest::set_legacy_client_steam_id(uint64_t value) {
  _internal_set_legacy_client_steam_id(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramConnectRequest.legacy_client_steam_id)
}

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

// CMsgSteamDatagramConnectOK

// optional fixed32 client_connection_id = 1;
inline bool CMsgSteamDatagramConnectOK::_internal_has_client_connection_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgSteamDatagramConnectOK::has_client_connection_id() const {
  return _internal_has_client_connection_id();
}
inline void CMsgSteamDatagramConnectOK::clear_client_connection_id() {
  _impl_.client_connection_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t CMsgSteamDatagramConnectOK::_internal_client_connection_id() const {
  return _impl_.client_connection_id_;
}
inline uint32_t CMsgSteamDatagramConnectOK::client_connection_id() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectOK.client_connection_id)
  return _internal_client_connection_id();
}
inline void CMsgSteamDatagramConnectOK::_internal_set_client_connection_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.client_connection_id_ = value;
}
inline void CMsgSteamDatagramConnectOK::set_client_connection_id(uint32_t value) {
  _internal_set_client_connection_id(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramConnectOK.client_connection_id)
}

// optional fixed32 server_connection_id = 7;
inline bool CMsgSteamDatagramConnectOK::_internal_has_server_connection_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool CMsgSteamDatagramConnectOK::has_server_connection_id() const {
  return _internal_has_server_connection_id();
}
inline void CMsgSteamDatagramConnectOK::clear_server_connection_id() {
  _impl_.server_connection_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline uint32_t CMsgSteamDatagramConnectOK::_internal_server_connection_id() const {
  return _impl_.server_connection_id_;
}
inline uint32_t CMsgSteamDatagramConnectOK::server_connection_id() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectOK.server_connection_id)
  return _internal_server_connection_id();
}
inline void CMsgSteamDatagramConnectOK::_internal_set_server_connection_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.server_connection_id_ = value;
}
inline void CMsgSteamDatagramConnectOK::set_server_connection_id(uint32_t value) {
  _internal_set_server_connection_id(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramConnectOK.server_connection_id)
}

// optional fixed64 your_timestamp = 3;
inline bool CMsgSteamDatagramConnectOK::_internal_has_your_timestamp() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CMsgSteamDatagramConnectOK::has_your_timestamp() const {
  return _internal_has_your_timestamp();
}
inline void CMsgSteamDatagramConnectOK::clear_your_timestamp() {
  _impl_.your_timestamp_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline uint64_t CMsgSteamDatagramConnectOK::_internal_your_timestamp() const {
  return _impl_.your_timestamp_;
}
inline uint64_t CMsgSteamDatagramConnectOK::your_timestamp() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectOK.your_timestamp)
  return _internal_your_timestamp();
}
inline void CMsgSteamDatagramConnectOK::_internal_set_your_timestamp(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.your_timestamp_ = value;
}
inline void CMsgSteamDatagramConnectOK::set_your_timestamp(uint64_t value) {
  _internal_set_your_timestamp(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramConnectOK.your_timestamp)
}

// optional uint32 delay_time_usec = 4;
inline bool CMsgSteamDatagramConnectOK::_internal_has_delay_time_usec() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool CMsgSteamDatagramConnectOK::has_delay_time_usec() const {
  return _internal_has_delay_time_usec();
}
inline void CMsgSteamDatagramConnectOK::clear_delay_time_usec() {
  _impl_.delay_time_usec_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline uint32_t CMsgSteamDatagramConnectOK::_internal_delay_time_usec() const {
  return _impl_.delay_time_usec_;
}
inline uint32_t CMsgSteamDatagramConnectOK::delay_time_usec() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectOK.delay_time_usec)
  return _internal_delay_time_usec();
}
inline void CMsgSteamDatagramConnectOK::_internal_set_delay_time_usec(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.delay_time_usec_ = value;
}
inline void CMsgSteamDatagramConnectOK::set_delay_time_usec(uint32_t value) {
  _internal_set_delay_time_usec(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramConnectOK.delay_time_usec)
}

// optional uint32 gameserver_relay_session_id = 2;
inline bool CMsgSteamDatagramConnectOK::_internal_has_gameserver_relay_session_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CMsgSteamDatagramConnectOK::has_gameserver_relay_session_id() const {
  return _internal_has_gameserver_relay_session_id();
}
inline void CMsgSteamDatagramConnectOK::clear_gameserver_relay_session_id() {
  _impl_.gameserver_relay_session_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t CMsgSteamDatagramConnectOK::_internal_gameserver_relay_session_id() const {
  return _impl_.gameserver_relay_session_id_;
}
inline uint32_t CMsgSteamDatagramConnectOK::gameserver_relay_session_id() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectOK.gameserver_relay_session_id)
  return _internal_gameserver_relay_session_id();
}
inline void CMsgSteamDatagramConnectOK::_internal_set_gameserver_relay_session_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.gameserver_relay_session_id_ = value;
}
inline void CMsgSteamDatagramConnectOK::set_gameserver_relay_session_id(uint32_t value) {
  _internal_set_gameserver_relay_session_id(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramConnectOK.gameserver_relay_session_id)
}

// optional .CMsgSteamDatagramSessionCryptInfoSigned crypt = 5;
inline bool CMsgSteamDatagramConnectOK::_internal_has_crypt() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.crypt_ != nullptr);
  return value;
}
inline bool CMsgSteamDatagramConnectOK::has_crypt() const {
  return _internal_has_crypt();
}
inline const ::CMsgSteamDatagramSessionCryptInfoSigned& CMsgSteamDatagramConnectOK::_internal_crypt() const {
  const ::CMsgSteamDatagramSessionCryptInfoSigned* p = _impl_.crypt_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgSteamDatagramSessionCryptInfoSigned&>(
      ::_CMsgSteamDatagramSessionCryptInfoSigned_default_instance_);
}
inline const ::CMsgSteamDatagramSessionCryptInfoSigned& CMsgSteamDatagramConnectOK::crypt() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectOK.crypt)
  return _internal_crypt();
}
inline void CMsgSteamDatagramConnectOK::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:CMsgSteamDatagramConnectOK.crypt)
}
inline ::CMsgSteamDatagramSessionCryptInfoSigned* CMsgSteamDatagramConnectOK::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* CMsgSteamDatagramConnectOK::unsafe_arena_release_crypt() {
  // @@protoc_insertion_point(field_release:CMsgSteamDatagramConnectOK.crypt)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgSteamDatagramSessionCryptInfoSigned* temp = _impl_.crypt_;
  _impl_.crypt_ = nullptr;
  return temp;
}
inline ::CMsgSteamDatagramSessionCryptInfoSigned* CMsgSteamDatagramConnectOK::_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* CMsgSteamDatagramConnectOK::mutable_crypt() {
  ::CMsgSteamDatagramSessionCryptInfoSigned* _msg = _internal_mutable_crypt();
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramConnectOK.crypt)
  return _msg;
}
inline void CMsgSteamDatagramConnectOK::set_allocated_crypt(::CMsgSteamDatagramSessionCryptInfoSigned* crypt) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.crypt_);
  }
  if (crypt) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(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:CMsgSteamDatagramConnectOK.crypt)
}

// optional .CMsgSteamDatagramCertificateSigned cert = 6;
inline bool CMsgSteamDatagramConnectOK::_internal_has_cert() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.cert_ != nullptr);
  return value;
}
inline bool CMsgSteamDatagramConnectOK::has_cert() const {
  return _internal_has_cert();
}
inline const ::CMsgSteamDatagramCertificateSigned& CMsgSteamDatagramConnectOK::_internal_cert() const {
  const ::CMsgSteamDatagramCertificateSigned* p = _impl_.cert_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgSteamDatagramCertificateSigned&>(
      ::_CMsgSteamDatagramCertificateSigned_default_instance_);
}
inline const ::CMsgSteamDatagramCertificateSigned& CMsgSteamDatagramConnectOK::cert() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectOK.cert)
  return _internal_cert();
}
inline void CMsgSteamDatagramConnectOK::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:CMsgSteamDatagramConnectOK.cert)
}
inline ::CMsgSteamDatagramCertificateSigned* CMsgSteamDatagramConnectOK::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* CMsgSteamDatagramConnectOK::unsafe_arena_release_cert() {
  // @@protoc_insertion_point(field_release:CMsgSteamDatagramConnectOK.cert)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgSteamDatagramCertificateSigned* temp = _impl_.cert_;
  _impl_.cert_ = nullptr;
  return temp;
}
inline ::CMsgSteamDatagramCertificateSigned* CMsgSteamDatagramConnectOK::_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* CMsgSteamDatagramConnectOK::mutable_cert() {
  ::CMsgSteamDatagramCertificateSigned* _msg = _internal_mutable_cert();
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramConnectOK.cert)
  return _msg;
}
inline void CMsgSteamDatagramConnectOK::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:CMsgSteamDatagramConnectOK.cert)
}

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

// CMsgSteamNetworkingP2PSDRRoutingSummary

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

// optional uint32 initial_ping_front_local = 2;
inline bool CMsgSteamNetworkingP2PSDRRoutingSummary::_internal_has_initial_ping_front_local() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgSteamNetworkingP2PSDRRoutingSummary::has_initial_ping_front_local() const {
  return _internal_has_initial_ping_front_local();
}
inline void CMsgSteamNetworkingP2PSDRRoutingSummary::clear_initial_ping_front_local() {
  _impl_.initial_ping_front_local_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t CMsgSteamNetworkingP2PSDRRoutingSummary::_internal_initial_ping_front_local() const {
  return _impl_.initial_ping_front_local_;
}
inline uint32_t CMsgSteamNetworkingP2PSDRRoutingSummary::initial_ping_front_local() const {
  // @@protoc_insertion_point(field_get:CMsgSteamNetworkingP2PSDRRoutingSummary.initial_ping_front_local)
  return _internal_initial_ping_front_local();
}
inline void CMsgSteamNetworkingP2PSDRRoutingSummary::_internal_set_initial_ping_front_local(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.initial_ping_front_local_ = value;
}
inline void CMsgSteamNetworkingP2PSDRRoutingSummary::set_initial_ping_front_local(uint32_t value) {
  _internal_set_initial_ping_front_local(value);
  // @@protoc_insertion_point(field_set:CMsgSteamNetworkingP2PSDRRoutingSummary.initial_ping_front_local)
}

// optional uint32 initial_ping_front_remote = 3;
inline bool CMsgSteamNetworkingP2PSDRRoutingSummary::_internal_has_initial_ping_front_remote() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgSteamNetworkingP2PSDRRoutingSummary::has_initial_ping_front_remote() const {
  return _internal_has_initial_ping_front_remote();
}
inline void CMsgSteamNetworkingP2PSDRRoutingSummary::clear_initial_ping_front_remote() {
  _impl_.initial_ping_front_remote_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t CMsgSteamNetworkingP2PSDRRoutingSummary::_internal_initial_ping_front_remote() const {
  return _impl_.initial_ping_front_remote_;
}
inline uint32_t CMsgSteamNetworkingP2PSDRRoutingSummary::initial_ping_front_remote() const {
  // @@protoc_insertion_point(field_get:CMsgSteamNetworkingP2PSDRRoutingSummary.initial_ping_front_remote)
  return _internal_initial_ping_front_remote();
}
inline void CMsgSteamNetworkingP2PSDRRoutingSummary::_internal_set_initial_ping_front_remote(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.initial_ping_front_remote_ = value;
}
inline void CMsgSteamNetworkingP2PSDRRoutingSummary::set_initial_ping_front_remote(uint32_t value) {
  _internal_set_initial_ping_front_remote(value);
  // @@protoc_insertion_point(field_set:CMsgSteamNetworkingP2PSDRRoutingSummary.initial_ping_front_remote)
}

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

// optional fixed32 initial_pop_local = 5;
inline bool CMsgSteamNetworkingP2PSDRRoutingSummary::_internal_has_initial_pop_local() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CMsgSteamNetworkingP2PSDRRoutingSummary::has_initial_pop_local() const {
  return _internal_has_initial_pop_local();
}
inline void CMsgSteamNetworkingP2PSDRRoutingSummary::clear_initial_pop_local() {
  _impl_.initial_pop_local_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline uint32_t CMsgSteamNetworkingP2PSDRRoutingSummary::_internal_initial_pop_local() const {
  return _impl_.initial_pop_local_;
}
inline uint32_t CMsgSteamNetworkingP2PSDRRoutingSummary::initial_pop_local() const {
  // @@protoc_insertion_point(field_get:CMsgSteamNetworkingP2PSDRRoutingSummary.initial_pop_local)
  return _internal_initial_pop_local();
}
inline void CMsgSteamNetworkingP2PSDRRoutingSummary::_internal_set_initial_pop_local(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.initial_pop_local_ = value;
}
inline void CMsgSteamNetworkingP2PSDRRoutingSummary::set_initial_pop_local(uint32_t value) {
  _internal_set_initial_pop_local(value);
  // @@protoc_insertion_point(field_set:CMsgSteamNetworkingP2PSDRRoutingSummary.initial_pop_local)
}

// optional fixed32 initial_pop_remote = 6;
inline bool CMsgSteamNetworkingP2PSDRRoutingSummary::_internal_has_initial_pop_remote() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool CMsgSteamNetworkingP2PSDRRoutingSummary::has_initial_pop_remote() const {
  return _internal_has_initial_pop_remote();
}
inline void CMsgSteamNetworkingP2PSDRRoutingSummary::clear_initial_pop_remote() {
  _impl_.initial_pop_remote_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline uint32_t CMsgSteamNetworkingP2PSDRRoutingSummary::_internal_initial_pop_remote() const {
  return _impl_.initial_pop_remote_;
}
inline uint32_t CMsgSteamNetworkingP2PSDRRoutingSummary::initial_pop_remote() const {
  // @@protoc_insertion_point(field_get:CMsgSteamNetworkingP2PSDRRoutingSummary.initial_pop_remote)
  return _internal_initial_pop_remote();
}
inline void CMsgSteamNetworkingP2PSDRRoutingSummary::_internal_set_initial_pop_remote(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.initial_pop_remote_ = value;
}
inline void CMsgSteamNetworkingP2PSDRRoutingSummary::set_initial_pop_remote(uint32_t value) {
  _internal_set_initial_pop_remote(value);
  // @@protoc_insertion_point(field_set:CMsgSteamNetworkingP2PSDRRoutingSummary.initial_pop_remote)
}

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

// optional uint32 best_ping_front_local = 12;
inline bool CMsgSteamNetworkingP2PSDRRoutingSummary::_internal_has_best_ping_front_local() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool CMsgSteamNetworkingP2PSDRRoutingSummary::has_best_ping_front_local() const {
  return _internal_has_best_ping_front_local();
}
inline void CMsgSteamNetworkingP2PSDRRoutingSummary::clear_best_ping_front_local() {
  _impl_.best_ping_front_local_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline uint32_t CMsgSteamNetworkingP2PSDRRoutingSummary::_internal_best_ping_front_local() const {
  return _impl_.best_ping_front_local_;
}
inline uint32_t CMsgSteamNetworkingP2PSDRRoutingSummary::best_ping_front_local() const {
  // @@protoc_insertion_point(field_get:CMsgSteamNetworkingP2PSDRRoutingSummary.best_ping_front_local)
  return _internal_best_ping_front_local();
}
inline void CMsgSteamNetworkingP2PSDRRoutingSummary::_internal_set_best_ping_front_local(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.best_ping_front_local_ = value;
}
inline void CMsgSteamNetworkingP2PSDRRoutingSummary::set_best_ping_front_local(uint32_t value) {
  _internal_set_best_ping_front_local(value);
  // @@protoc_insertion_point(field_set:CMsgSteamNetworkingP2PSDRRoutingSummary.best_ping_front_local)
}

// optional uint32 best_ping_front_remote = 13;
inline bool CMsgSteamNetworkingP2PSDRRoutingSummary::_internal_has_best_ping_front_remote() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool CMsgSteamNetworkingP2PSDRRoutingSummary::has_best_ping_front_remote() const {
  return _internal_has_best_ping_front_remote();
}
inline void CMsgSteamNetworkingP2PSDRRoutingSummary::clear_best_ping_front_remote() {
  _impl_.best_ping_front_remote_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline uint32_t CMsgSteamNetworkingP2PSDRRoutingSummary::_internal_best_ping_front_remote() const {
  return _impl_.best_ping_front_remote_;
}
inline uint32_t CMsgSteamNetworkingP2PSDRRoutingSummary::best_ping_front_remote() const {
  // @@protoc_insertion_point(field_get:CMsgSteamNetworkingP2PSDRRoutingSummary.best_ping_front_remote)
  return _internal_best_ping_front_remote();
}
inline void CMsgSteamNetworkingP2PSDRRoutingSummary::_internal_set_best_ping_front_remote(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000400u;
  _impl_.best_ping_front_remote_ = value;
}
inline void CMsgSteamNetworkingP2PSDRRoutingSummary::set_best_ping_front_remote(uint32_t value) {
  _internal_set_best_ping_front_remote(value);
  // @@protoc_insertion_point(field_set:CMsgSteamNetworkingP2PSDRRoutingSummary.best_ping_front_remote)
}

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

// optional fixed32 best_pop_local = 15;
inline bool CMsgSteamNetworkingP2PSDRRoutingSummary::_internal_has_best_pop_local() const {
  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
  return value;
}
inline bool CMsgSteamNetworkingP2PSDRRoutingSummary::has_best_pop_local() const {
  return _internal_has_best_pop_local();
}
inline void CMsgSteamNetworkingP2PSDRRoutingSummary::clear_best_pop_local() {
  _impl_.best_pop_local_ = 0u;
  _impl_._has_bits_[0] &= ~0x00001000u;
}
inline uint32_t CMsgSteamNetworkingP2PSDRRoutingSummary::_internal_best_pop_local() const {
  return _impl_.best_pop_local_;
}
inline uint32_t CMsgSteamNetworkingP2PSDRRoutingSummary::best_pop_local() const {
  // @@protoc_insertion_point(field_get:CMsgSteamNetworkingP2PSDRRoutingSummary.best_pop_local)
  return _internal_best_pop_local();
}
inline void CMsgSteamNetworkingP2PSDRRoutingSummary::_internal_set_best_pop_local(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00001000u;
  _impl_.best_pop_local_ = value;
}
inline void CMsgSteamNetworkingP2PSDRRoutingSummary::set_best_pop_local(uint32_t value) {
  _internal_set_best_pop_local(value);
  // @@protoc_insertion_point(field_set:CMsgSteamNetworkingP2PSDRRoutingSummary.best_pop_local)
}

// optional fixed32 best_pop_remote = 16;
inline bool CMsgSteamNetworkingP2PSDRRoutingSummary::_internal_has_best_pop_remote() const {
  bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0;
  return value;
}
inline bool CMsgSteamNetworkingP2PSDRRoutingSummary::has_best_pop_remote() const {
  return _internal_has_best_pop_remote();
}
inline void CMsgSteamNetworkingP2PSDRRoutingSummary::clear_best_pop_remote() {
  _impl_.best_pop_remote_ = 0u;
  _impl_._has_bits_[0] &= ~0x00002000u;
}
inline uint32_t CMsgSteamNetworkingP2PSDRRoutingSummary::_internal_best_pop_remote() const {
  return _impl_.best_pop_remote_;
}
inline uint32_t CMsgSteamNetworkingP2PSDRRoutingSummary::best_pop_remote() const {
  // @@protoc_insertion_point(field_get:CMsgSteamNetworkingP2PSDRRoutingSummary.best_pop_remote)
  return _internal_best_pop_remote();
}
inline void CMsgSteamNetworkingP2PSDRRoutingSummary::_internal_set_best_pop_remote(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00002000u;
  _impl_.best_pop_remote_ = value;
}
inline void CMsgSteamNetworkingP2PSDRRoutingSummary::set_best_pop_remote(uint32_t value) {
  _internal_set_best_pop_remote(value);
  // @@protoc_insertion_point(field_set:CMsgSteamNetworkingP2PSDRRoutingSummary.best_pop_remote)
}

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

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

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

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

// CMsgSteamDatagramP2PRoutingSummary

// optional .CMsgSteamNetworkingICESessionSummary ice = 2;
inline bool CMsgSteamDatagramP2PRoutingSummary::_internal_has_ice() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.ice_ != nullptr);
  return value;
}
inline bool CMsgSteamDatagramP2PRoutingSummary::has_ice() const {
  return _internal_has_ice();
}
inline const ::CMsgSteamNetworkingICESessionSummary& CMsgSteamDatagramP2PRoutingSummary::_internal_ice() const {
  const ::CMsgSteamNetworkingICESessionSummary* p = _impl_.ice_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgSteamNetworkingICESessionSummary&>(
      ::_CMsgSteamNetworkingICESessionSummary_default_instance_);
}
inline const ::CMsgSteamNetworkingICESessionSummary& CMsgSteamDatagramP2PRoutingSummary::ice() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramP2PRoutingSummary.ice)
  return _internal_ice();
}
inline void CMsgSteamDatagramP2PRoutingSummary::unsafe_arena_set_allocated_ice(
    ::CMsgSteamNetworkingICESessionSummary* 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:CMsgSteamDatagramP2PRoutingSummary.ice)
}
inline ::CMsgSteamNetworkingICESessionSummary* CMsgSteamDatagramP2PRoutingSummary::release_ice() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgSteamNetworkingICESessionSummary* 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 ::CMsgSteamNetworkingICESessionSummary* CMsgSteamDatagramP2PRoutingSummary::unsafe_arena_release_ice() {
  // @@protoc_insertion_point(field_release:CMsgSteamDatagramP2PRoutingSummary.ice)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgSteamNetworkingICESessionSummary* temp = _impl_.ice_;
  _impl_.ice_ = nullptr;
  return temp;
}
inline ::CMsgSteamNetworkingICESessionSummary* CMsgSteamDatagramP2PRoutingSummary::_internal_mutable_ice() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.ice_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgSteamNetworkingICESessionSummary>(GetArenaForAllocation());
    _impl_.ice_ = p;
  }
  return _impl_.ice_;
}
inline ::CMsgSteamNetworkingICESessionSummary* CMsgSteamDatagramP2PRoutingSummary::mutable_ice() {
  ::CMsgSteamNetworkingICESessionSummary* _msg = _internal_mutable_ice();
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramP2PRoutingSummary.ice)
  return _msg;
}
inline void CMsgSteamDatagramP2PRoutingSummary::set_allocated_ice(::CMsgSteamNetworkingICESessionSummary* ice) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.ice_);
  }
  if (ice) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(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:CMsgSteamDatagramP2PRoutingSummary.ice)
}

// optional .CMsgSteamNetworkingP2PSDRRoutingSummary sdr = 3;
inline bool CMsgSteamDatagramP2PRoutingSummary::_internal_has_sdr() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.sdr_ != nullptr);
  return value;
}
inline bool CMsgSteamDatagramP2PRoutingSummary::has_sdr() const {
  return _internal_has_sdr();
}
inline void CMsgSteamDatagramP2PRoutingSummary::clear_sdr() {
  if (_impl_.sdr_ != nullptr) _impl_.sdr_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const ::CMsgSteamNetworkingP2PSDRRoutingSummary& CMsgSteamDatagramP2PRoutingSummary::_internal_sdr() const {
  const ::CMsgSteamNetworkingP2PSDRRoutingSummary* p = _impl_.sdr_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgSteamNetworkingP2PSDRRoutingSummary&>(
      ::_CMsgSteamNetworkingP2PSDRRoutingSummary_default_instance_);
}
inline const ::CMsgSteamNetworkingP2PSDRRoutingSummary& CMsgSteamDatagramP2PRoutingSummary::sdr() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramP2PRoutingSummary.sdr)
  return _internal_sdr();
}
inline void CMsgSteamDatagramP2PRoutingSummary::unsafe_arena_set_allocated_sdr(
    ::CMsgSteamNetworkingP2PSDRRoutingSummary* sdr) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.sdr_);
  }
  _impl_.sdr_ = sdr;
  if (sdr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgSteamDatagramP2PRoutingSummary.sdr)
}
inline ::CMsgSteamNetworkingP2PSDRRoutingSummary* CMsgSteamDatagramP2PRoutingSummary::release_sdr() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgSteamNetworkingP2PSDRRoutingSummary* temp = _impl_.sdr_;
  _impl_.sdr_ = 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 ::CMsgSteamNetworkingP2PSDRRoutingSummary* CMsgSteamDatagramP2PRoutingSummary::unsafe_arena_release_sdr() {
  // @@protoc_insertion_point(field_release:CMsgSteamDatagramP2PRoutingSummary.sdr)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgSteamNetworkingP2PSDRRoutingSummary* temp = _impl_.sdr_;
  _impl_.sdr_ = nullptr;
  return temp;
}
inline ::CMsgSteamNetworkingP2PSDRRoutingSummary* CMsgSteamDatagramP2PRoutingSummary::_internal_mutable_sdr() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.sdr_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgSteamNetworkingP2PSDRRoutingSummary>(GetArenaForAllocation());
    _impl_.sdr_ = p;
  }
  return _impl_.sdr_;
}
inline ::CMsgSteamNetworkingP2PSDRRoutingSummary* CMsgSteamDatagramP2PRoutingSummary::mutable_sdr() {
  ::CMsgSteamNetworkingP2PSDRRoutingSummary* _msg = _internal_mutable_sdr();
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramP2PRoutingSummary.sdr)
  return _msg;
}
inline void CMsgSteamDatagramP2PRoutingSummary::set_allocated_sdr(::CMsgSteamNetworkingP2PSDRRoutingSummary* sdr) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.sdr_;
  }
  if (sdr) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(sdr);
    if (message_arena != submessage_arena) {
      sdr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, sdr, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.sdr_ = sdr;
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamDatagramP2PRoutingSummary.sdr)
}

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

// CMsgSteamDatagramConnectionClosed

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

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

// optional string from_identity_string = 15;
inline bool CMsgSteamDatagramConnectionClosed::_internal_has_from_identity_string() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgSteamDatagramConnectionClosed::has_from_identity_string() const {
  return _internal_has_from_identity_string();
}
inline void CMsgSteamDatagramConnectionClosed::clear_from_identity_string() {
  _impl_.from_identity_string_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& CMsgSteamDatagramConnectionClosed::from_identity_string() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectionClosed.from_identity_string)
  return _internal_from_identity_string();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgSteamDatagramConnectionClosed::set_from_identity_string(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.from_identity_string_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramConnectionClosed.from_identity_string)
}
inline std::string* CMsgSteamDatagramConnectionClosed::mutable_from_identity_string() {
  std::string* _s = _internal_mutable_from_identity_string();
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramConnectionClosed.from_identity_string)
  return _s;
}
inline const std::string& CMsgSteamDatagramConnectionClosed::_internal_from_identity_string() const {
  return _impl_.from_identity_string_.Get();
}
inline void CMsgSteamDatagramConnectionClosed::_internal_set_from_identity_string(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.from_identity_string_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramConnectionClosed::_internal_mutable_from_identity_string() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.from_identity_string_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramConnectionClosed::release_from_identity_string() {
  // @@protoc_insertion_point(field_release:CMsgSteamDatagramConnectionClosed.from_identity_string)
  if (!_internal_has_from_identity_string()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* p = _impl_.from_identity_string_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.from_identity_string_.IsDefault()) {
    _impl_.from_identity_string_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgSteamDatagramConnectionClosed::set_allocated_from_identity_string(std::string* from_identity_string) {
  if (from_identity_string != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.from_identity_string_.SetAllocated(from_identity_string, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.from_identity_string_.IsDefault()) {
    _impl_.from_identity_string_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamDatagramConnectionClosed.from_identity_string)
}

// optional .CMsgSteamNetworkingIdentityLegacyBinary legacy_from_identity_binary = 13;
inline bool CMsgSteamDatagramConnectionClosed::_internal_has_legacy_from_identity_binary() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.legacy_from_identity_binary_ != nullptr);
  return value;
}
inline bool CMsgSteamDatagramConnectionClosed::has_legacy_from_identity_binary() const {
  return _internal_has_legacy_from_identity_binary();
}
inline const ::CMsgSteamNetworkingIdentityLegacyBinary& CMsgSteamDatagramConnectionClosed::_internal_legacy_from_identity_binary() const {
  const ::CMsgSteamNetworkingIdentityLegacyBinary* p = _impl_.legacy_from_identity_binary_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgSteamNetworkingIdentityLegacyBinary&>(
      ::_CMsgSteamNetworkingIdentityLegacyBinary_default_instance_);
}
inline const ::CMsgSteamNetworkingIdentityLegacyBinary& CMsgSteamDatagramConnectionClosed::legacy_from_identity_binary() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectionClosed.legacy_from_identity_binary)
  return _internal_legacy_from_identity_binary();
}
inline void CMsgSteamDatagramConnectionClosed::unsafe_arena_set_allocated_legacy_from_identity_binary(
    ::CMsgSteamNetworkingIdentityLegacyBinary* legacy_from_identity_binary) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.legacy_from_identity_binary_);
  }
  _impl_.legacy_from_identity_binary_ = legacy_from_identity_binary;
  if (legacy_from_identity_binary) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgSteamDatagramConnectionClosed.legacy_from_identity_binary)
}
inline ::CMsgSteamNetworkingIdentityLegacyBinary* CMsgSteamDatagramConnectionClosed::release_legacy_from_identity_binary() {
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::CMsgSteamNetworkingIdentityLegacyBinary* temp = _impl_.legacy_from_identity_binary_;
  _impl_.legacy_from_identity_binary_ = 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 ::CMsgSteamNetworkingIdentityLegacyBinary* CMsgSteamDatagramConnectionClosed::unsafe_arena_release_legacy_from_identity_binary() {
  // @@protoc_insertion_point(field_release:CMsgSteamDatagramConnectionClosed.legacy_from_identity_binary)
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::CMsgSteamNetworkingIdentityLegacyBinary* temp = _impl_.legacy_from_identity_binary_;
  _impl_.legacy_from_identity_binary_ = nullptr;
  return temp;
}
inline ::CMsgSteamNetworkingIdentityLegacyBinary* CMsgSteamDatagramConnectionClosed::_internal_mutable_legacy_from_identity_binary() {
  _impl_._has_bits_[0] |= 0x00000008u;
  if (_impl_.legacy_from_identity_binary_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgSteamNetworkingIdentityLegacyBinary>(GetArenaForAllocation());
    _impl_.legacy_from_identity_binary_ = p;
  }
  return _impl_.legacy_from_identity_binary_;
}
inline ::CMsgSteamNetworkingIdentityLegacyBinary* CMsgSteamDatagramConnectionClosed::mutable_legacy_from_identity_binary() {
  ::CMsgSteamNetworkingIdentityLegacyBinary* _msg = _internal_mutable_legacy_from_identity_binary();
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramConnectionClosed.legacy_from_identity_binary)
  return _msg;
}
inline void CMsgSteamDatagramConnectionClosed::set_allocated_legacy_from_identity_binary(::CMsgSteamNetworkingIdentityLegacyBinary* legacy_from_identity_binary) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.legacy_from_identity_binary_);
  }
  if (legacy_from_identity_binary) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(legacy_from_identity_binary));
    if (message_arena != submessage_arena) {
      legacy_from_identity_binary = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, legacy_from_identity_binary, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.legacy_from_identity_binary_ = legacy_from_identity_binary;
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamDatagramConnectionClosed.legacy_from_identity_binary)
}

// optional fixed64 legacy_from_steam_id = 3;
inline bool CMsgSteamDatagramConnectionClosed::_internal_has_legacy_from_steam_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool CMsgSteamDatagramConnectionClosed::has_legacy_from_steam_id() const {
  return _internal_has_legacy_from_steam_id();
}
inline void CMsgSteamDatagramConnectionClosed::clear_legacy_from_steam_id() {
  _impl_.legacy_from_steam_id_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline uint64_t CMsgSteamDatagramConnectionClosed::_internal_legacy_from_steam_id() const {
  return _impl_.legacy_from_steam_id_;
}
inline uint64_t CMsgSteamDatagramConnectionClosed::legacy_from_steam_id() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectionClosed.legacy_from_steam_id)
  return _internal_legacy_from_steam_id();
}
inline void CMsgSteamDatagramConnectionClosed::_internal_set_legacy_from_steam_id(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.legacy_from_steam_id_ = value;
}
inline void CMsgSteamDatagramConnectionClosed::set_legacy_from_steam_id(uint64_t value) {
  _internal_set_legacy_from_steam_id(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramConnectionClosed.legacy_from_steam_id)
}

// optional uint32 legacy_gameserver_relay_session_id = 2;
inline bool CMsgSteamDatagramConnectionClosed::_internal_has_legacy_gameserver_relay_session_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool CMsgSteamDatagramConnectionClosed::has_legacy_gameserver_relay_session_id() const {
  return _internal_has_legacy_gameserver_relay_session_id();
}
inline void CMsgSteamDatagramConnectionClosed::clear_legacy_gameserver_relay_session_id() {
  _impl_.legacy_gameserver_relay_session_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline uint32_t CMsgSteamDatagramConnectionClosed::_internal_legacy_gameserver_relay_session_id() const {
  return _impl_.legacy_gameserver_relay_session_id_;
}
inline uint32_t CMsgSteamDatagramConnectionClosed::legacy_gameserver_relay_session_id() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectionClosed.legacy_gameserver_relay_session_id)
  return _internal_legacy_gameserver_relay_session_id();
}
inline void CMsgSteamDatagramConnectionClosed::_internal_set_legacy_gameserver_relay_session_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.legacy_gameserver_relay_session_id_ = value;
}
inline void CMsgSteamDatagramConnectionClosed::set_legacy_gameserver_relay_session_id(uint32_t value) {
  _internal_set_legacy_gameserver_relay_session_id(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramConnectionClosed.legacy_gameserver_relay_session_id)
}

// optional fixed32 to_relay_session_id = 9;
inline bool CMsgSteamDatagramConnectionClosed::_internal_has_to_relay_session_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0;
  return value;
}
inline bool CMsgSteamDatagramConnectionClosed::has_to_relay_session_id() const {
  return _internal_has_to_relay_session_id();
}
inline void CMsgSteamDatagramConnectionClosed::clear_to_relay_session_id() {
  _impl_.to_relay_session_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00002000u;
}
inline uint32_t CMsgSteamDatagramConnectionClosed::_internal_to_relay_session_id() const {
  return _impl_.to_relay_session_id_;
}
inline uint32_t CMsgSteamDatagramConnectionClosed::to_relay_session_id() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectionClosed.to_relay_session_id)
  return _internal_to_relay_session_id();
}
inline void CMsgSteamDatagramConnectionClosed::_internal_set_to_relay_session_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00002000u;
  _impl_.to_relay_session_id_ = value;
}
inline void CMsgSteamDatagramConnectionClosed::set_to_relay_session_id(uint32_t value) {
  _internal_set_to_relay_session_id(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramConnectionClosed.to_relay_session_id)
}

// optional fixed32 from_relay_session_id = 10;
inline bool CMsgSteamDatagramConnectionClosed::_internal_has_from_relay_session_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0;
  return value;
}
inline bool CMsgSteamDatagramConnectionClosed::has_from_relay_session_id() const {
  return _internal_has_from_relay_session_id();
}
inline void CMsgSteamDatagramConnectionClosed::clear_from_relay_session_id() {
  _impl_.from_relay_session_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00004000u;
}
inline uint32_t CMsgSteamDatagramConnectionClosed::_internal_from_relay_session_id() const {
  return _impl_.from_relay_session_id_;
}
inline uint32_t CMsgSteamDatagramConnectionClosed::from_relay_session_id() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectionClosed.from_relay_session_id)
  return _internal_from_relay_session_id();
}
inline void CMsgSteamDatagramConnectionClosed::_internal_set_from_relay_session_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00004000u;
  _impl_.from_relay_session_id_ = value;
}
inline void CMsgSteamDatagramConnectionClosed::set_from_relay_session_id(uint32_t value) {
  _internal_set_from_relay_session_id(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramConnectionClosed.from_relay_session_id)
}

// optional bytes forward_target_relay_routing_token = 11;
inline bool CMsgSteamDatagramConnectionClosed::_internal_has_forward_target_relay_routing_token() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgSteamDatagramConnectionClosed::has_forward_target_relay_routing_token() const {
  return _internal_has_forward_target_relay_routing_token();
}
inline void CMsgSteamDatagramConnectionClosed::clear_forward_target_relay_routing_token() {
  _impl_.forward_target_relay_routing_token_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& CMsgSteamDatagramConnectionClosed::forward_target_relay_routing_token() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectionClosed.forward_target_relay_routing_token)
  return _internal_forward_target_relay_routing_token();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgSteamDatagramConnectionClosed::set_forward_target_relay_routing_token(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.forward_target_relay_routing_token_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramConnectionClosed.forward_target_relay_routing_token)
}
inline std::string* CMsgSteamDatagramConnectionClosed::mutable_forward_target_relay_routing_token() {
  std::string* _s = _internal_mutable_forward_target_relay_routing_token();
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramConnectionClosed.forward_target_relay_routing_token)
  return _s;
}
inline const std::string& CMsgSteamDatagramConnectionClosed::_internal_forward_target_relay_routing_token() const {
  return _impl_.forward_target_relay_routing_token_.Get();
}
inline void CMsgSteamDatagramConnectionClosed::_internal_set_forward_target_relay_routing_token(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.forward_target_relay_routing_token_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramConnectionClosed::_internal_mutable_forward_target_relay_routing_token() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.forward_target_relay_routing_token_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramConnectionClosed::release_forward_target_relay_routing_token() {
  // @@protoc_insertion_point(field_release:CMsgSteamDatagramConnectionClosed.forward_target_relay_routing_token)
  if (!_internal_has_forward_target_relay_routing_token()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.forward_target_relay_routing_token_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.forward_target_relay_routing_token_.IsDefault()) {
    _impl_.forward_target_relay_routing_token_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgSteamDatagramConnectionClosed::set_allocated_forward_target_relay_routing_token(std::string* forward_target_relay_routing_token) {
  if (forward_target_relay_routing_token != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.forward_target_relay_routing_token_.SetAllocated(forward_target_relay_routing_token, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.forward_target_relay_routing_token_.IsDefault()) {
    _impl_.forward_target_relay_routing_token_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamDatagramConnectionClosed.forward_target_relay_routing_token)
}

// optional uint32 forward_target_revision = 12;
inline bool CMsgSteamDatagramConnectionClosed::_internal_has_forward_target_revision() const {
  bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0;
  return value;
}
inline bool CMsgSteamDatagramConnectionClosed::has_forward_target_revision() const {
  return _internal_has_forward_target_revision();
}
inline void CMsgSteamDatagramConnectionClosed::clear_forward_target_revision() {
  _impl_.forward_target_revision_ = 0u;
  _impl_._has_bits_[0] &= ~0x00008000u;
}
inline uint32_t CMsgSteamDatagramConnectionClosed::_internal_forward_target_revision() const {
  return _impl_.forward_target_revision_;
}
inline uint32_t CMsgSteamDatagramConnectionClosed::forward_target_revision() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectionClosed.forward_target_revision)
  return _internal_forward_target_revision();
}
inline void CMsgSteamDatagramConnectionClosed::_internal_set_forward_target_revision(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00008000u;
  _impl_.forward_target_revision_ = value;
}
inline void CMsgSteamDatagramConnectionClosed::set_forward_target_revision(uint32_t value) {
  _internal_set_forward_target_revision(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramConnectionClosed.forward_target_revision)
}

// optional .CMsgSteamDatagramConnectionClosed.ERelayMode relay_mode = 4 [default = None];
inline bool CMsgSteamDatagramConnectionClosed::_internal_has_relay_mode() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool CMsgSteamDatagramConnectionClosed::has_relay_mode() const {
  return _internal_has_relay_mode();
}
inline void CMsgSteamDatagramConnectionClosed::clear_relay_mode() {
  _impl_.relay_mode_ = 0;
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline ::CMsgSteamDatagramConnectionClosed_ERelayMode CMsgSteamDatagramConnectionClosed::_internal_relay_mode() const {
  return static_cast< ::CMsgSteamDatagramConnectionClosed_ERelayMode >(_impl_.relay_mode_);
}
inline ::CMsgSteamDatagramConnectionClosed_ERelayMode CMsgSteamDatagramConnectionClosed::relay_mode() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectionClosed.relay_mode)
  return _internal_relay_mode();
}
inline void CMsgSteamDatagramConnectionClosed::_internal_set_relay_mode(::CMsgSteamDatagramConnectionClosed_ERelayMode value) {
  assert(::CMsgSteamDatagramConnectionClosed_ERelayMode_IsValid(value));
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.relay_mode_ = value;
}
inline void CMsgSteamDatagramConnectionClosed::set_relay_mode(::CMsgSteamDatagramConnectionClosed_ERelayMode value) {
  _internal_set_relay_mode(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramConnectionClosed.relay_mode)
}

// optional string debug = 5;
inline bool CMsgSteamDatagramConnectionClosed::_internal_has_debug() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgSteamDatagramConnectionClosed::has_debug() const {
  return _internal_has_debug();
}
inline void CMsgSteamDatagramConnectionClosed::clear_debug() {
  _impl_.debug_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CMsgSteamDatagramConnectionClosed::debug() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectionClosed.debug)
  return _internal_debug();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgSteamDatagramConnectionClosed::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:CMsgSteamDatagramConnectionClosed.debug)
}
inline std::string* CMsgSteamDatagramConnectionClosed::mutable_debug() {
  std::string* _s = _internal_mutable_debug();
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramConnectionClosed.debug)
  return _s;
}
inline const std::string& CMsgSteamDatagramConnectionClosed::_internal_debug() const {
  return _impl_.debug_.Get();
}
inline void CMsgSteamDatagramConnectionClosed::_internal_set_debug(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.debug_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramConnectionClosed::_internal_mutable_debug() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.debug_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramConnectionClosed::release_debug() {
  // @@protoc_insertion_point(field_release:CMsgSteamDatagramConnectionClosed.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 CMsgSteamDatagramConnectionClosed::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:CMsgSteamDatagramConnectionClosed.debug)
}

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

// optional fixed64 routing_secret = 14;
inline bool CMsgSteamDatagramConnectionClosed::_internal_has_routing_secret() const {
  bool value = (_impl_._has_bits_[0] & 0x00010000u) != 0;
  return value;
}
inline bool CMsgSteamDatagramConnectionClosed::has_routing_secret() const {
  return _internal_has_routing_secret();
}
inline void CMsgSteamDatagramConnectionClosed::clear_routing_secret() {
  _impl_.routing_secret_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00010000u;
}
inline uint64_t CMsgSteamDatagramConnectionClosed::_internal_routing_secret() const {
  return _impl_.routing_secret_;
}
inline uint64_t CMsgSteamDatagramConnectionClosed::routing_secret() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectionClosed.routing_secret)
  return _internal_routing_secret();
}
inline void CMsgSteamDatagramConnectionClosed::_internal_set_routing_secret(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00010000u;
  _impl_.routing_secret_ = value;
}
inline void CMsgSteamDatagramConnectionClosed::set_routing_secret(uint64_t value) {
  _internal_set_routing_secret(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramConnectionClosed.routing_secret)
}

// optional bool not_primary_session = 16;
inline bool CMsgSteamDatagramConnectionClosed::_internal_has_not_primary_session() const {
  bool value = (_impl_._has_bits_[0] & 0x00020000u) != 0;
  return value;
}
inline bool CMsgSteamDatagramConnectionClosed::has_not_primary_session() const {
  return _internal_has_not_primary_session();
}
inline void CMsgSteamDatagramConnectionClosed::clear_not_primary_session() {
  _impl_.not_primary_session_ = false;
  _impl_._has_bits_[0] &= ~0x00020000u;
}
inline bool CMsgSteamDatagramConnectionClosed::_internal_not_primary_session() const {
  return _impl_.not_primary_session_;
}
inline bool CMsgSteamDatagramConnectionClosed::not_primary_session() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectionClosed.not_primary_session)
  return _internal_not_primary_session();
}
inline void CMsgSteamDatagramConnectionClosed::_internal_set_not_primary_session(bool value) {
  _impl_._has_bits_[0] |= 0x00020000u;
  _impl_.not_primary_session_ = value;
}
inline void CMsgSteamDatagramConnectionClosed::set_not_primary_session(bool value) {
  _internal_set_not_primary_session(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramConnectionClosed.not_primary_session)
}

// optional bool not_primary_transport = 19;
inline bool CMsgSteamDatagramConnectionClosed::_internal_has_not_primary_transport() const {
  bool value = (_impl_._has_bits_[0] & 0x00040000u) != 0;
  return value;
}
inline bool CMsgSteamDatagramConnectionClosed::has_not_primary_transport() const {
  return _internal_has_not_primary_transport();
}
inline void CMsgSteamDatagramConnectionClosed::clear_not_primary_transport() {
  _impl_.not_primary_transport_ = false;
  _impl_._has_bits_[0] &= ~0x00040000u;
}
inline bool CMsgSteamDatagramConnectionClosed::_internal_not_primary_transport() const {
  return _impl_.not_primary_transport_;
}
inline bool CMsgSteamDatagramConnectionClosed::not_primary_transport() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectionClosed.not_primary_transport)
  return _internal_not_primary_transport();
}
inline void CMsgSteamDatagramConnectionClosed::_internal_set_not_primary_transport(bool value) {
  _impl_._has_bits_[0] |= 0x00040000u;
  _impl_.not_primary_transport_ = value;
}
inline void CMsgSteamDatagramConnectionClosed::set_not_primary_transport(bool value) {
  _internal_set_not_primary_transport(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramConnectionClosed.not_primary_transport)
}

// optional bool relay_override_active = 22;
inline bool CMsgSteamDatagramConnectionClosed::_internal_has_relay_override_active() const {
  bool value = (_impl_._has_bits_[0] & 0x00080000u) != 0;
  return value;
}
inline bool CMsgSteamDatagramConnectionClosed::has_relay_override_active() const {
  return _internal_has_relay_override_active();
}
inline void CMsgSteamDatagramConnectionClosed::clear_relay_override_active() {
  _impl_.relay_override_active_ = false;
  _impl_._has_bits_[0] &= ~0x00080000u;
}
inline bool CMsgSteamDatagramConnectionClosed::_internal_relay_override_active() const {
  return _impl_.relay_override_active_;
}
inline bool CMsgSteamDatagramConnectionClosed::relay_override_active() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectionClosed.relay_override_active)
  return _internal_relay_override_active();
}
inline void CMsgSteamDatagramConnectionClosed::_internal_set_relay_override_active(bool value) {
  _impl_._has_bits_[0] |= 0x00080000u;
  _impl_.relay_override_active_ = value;
}
inline void CMsgSteamDatagramConnectionClosed::set_relay_override_active(bool value) {
  _internal_set_relay_override_active(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramConnectionClosed.relay_override_active)
}

// optional .CMsgSteamDatagramConnectionQuality quality_relay = 17;
inline bool CMsgSteamDatagramConnectionClosed::_internal_has_quality_relay() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.quality_relay_ != nullptr);
  return value;
}
inline bool CMsgSteamDatagramConnectionClosed::has_quality_relay() const {
  return _internal_has_quality_relay();
}
inline const ::CMsgSteamDatagramConnectionQuality& CMsgSteamDatagramConnectionClosed::_internal_quality_relay() const {
  const ::CMsgSteamDatagramConnectionQuality* p = _impl_.quality_relay_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgSteamDatagramConnectionQuality&>(
      ::_CMsgSteamDatagramConnectionQuality_default_instance_);
}
inline const ::CMsgSteamDatagramConnectionQuality& CMsgSteamDatagramConnectionClosed::quality_relay() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectionClosed.quality_relay)
  return _internal_quality_relay();
}
inline void CMsgSteamDatagramConnectionClosed::unsafe_arena_set_allocated_quality_relay(
    ::CMsgSteamDatagramConnectionQuality* quality_relay) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.quality_relay_);
  }
  _impl_.quality_relay_ = quality_relay;
  if (quality_relay) {
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgSteamDatagramConnectionClosed.quality_relay)
}
inline ::CMsgSteamDatagramConnectionQuality* CMsgSteamDatagramConnectionClosed::release_quality_relay() {
  _impl_._has_bits_[0] &= ~0x00000010u;
  ::CMsgSteamDatagramConnectionQuality* temp = _impl_.quality_relay_;
  _impl_.quality_relay_ = 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 ::CMsgSteamDatagramConnectionQuality* CMsgSteamDatagramConnectionClosed::unsafe_arena_release_quality_relay() {
  // @@protoc_insertion_point(field_release:CMsgSteamDatagramConnectionClosed.quality_relay)
  _impl_._has_bits_[0] &= ~0x00000010u;
  ::CMsgSteamDatagramConnectionQuality* temp = _impl_.quality_relay_;
  _impl_.quality_relay_ = nullptr;
  return temp;
}
inline ::CMsgSteamDatagramConnectionQuality* CMsgSteamDatagramConnectionClosed::_internal_mutable_quality_relay() {
  _impl_._has_bits_[0] |= 0x00000010u;
  if (_impl_.quality_relay_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgSteamDatagramConnectionQuality>(GetArenaForAllocation());
    _impl_.quality_relay_ = p;
  }
  return _impl_.quality_relay_;
}
inline ::CMsgSteamDatagramConnectionQuality* CMsgSteamDatagramConnectionClosed::mutable_quality_relay() {
  ::CMsgSteamDatagramConnectionQuality* _msg = _internal_mutable_quality_relay();
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramConnectionClosed.quality_relay)
  return _msg;
}
inline void CMsgSteamDatagramConnectionClosed::set_allocated_quality_relay(::CMsgSteamDatagramConnectionQuality* quality_relay) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.quality_relay_);
  }
  if (quality_relay) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(quality_relay));
    if (message_arena != submessage_arena) {
      quality_relay = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, quality_relay, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  _impl_.quality_relay_ = quality_relay;
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamDatagramConnectionClosed.quality_relay)
}

// optional .CMsgSteamDatagramConnectionQuality quality_e2e = 18;
inline bool CMsgSteamDatagramConnectionClosed::_internal_has_quality_e2e() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.quality_e2e_ != nullptr);
  return value;
}
inline bool CMsgSteamDatagramConnectionClosed::has_quality_e2e() const {
  return _internal_has_quality_e2e();
}
inline const ::CMsgSteamDatagramConnectionQuality& CMsgSteamDatagramConnectionClosed::_internal_quality_e2e() const {
  const ::CMsgSteamDatagramConnectionQuality* p = _impl_.quality_e2e_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgSteamDatagramConnectionQuality&>(
      ::_CMsgSteamDatagramConnectionQuality_default_instance_);
}
inline const ::CMsgSteamDatagramConnectionQuality& CMsgSteamDatagramConnectionClosed::quality_e2e() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectionClosed.quality_e2e)
  return _internal_quality_e2e();
}
inline void CMsgSteamDatagramConnectionClosed::unsafe_arena_set_allocated_quality_e2e(
    ::CMsgSteamDatagramConnectionQuality* quality_e2e) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.quality_e2e_);
  }
  _impl_.quality_e2e_ = quality_e2e;
  if (quality_e2e) {
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgSteamDatagramConnectionClosed.quality_e2e)
}
inline ::CMsgSteamDatagramConnectionQuality* CMsgSteamDatagramConnectionClosed::release_quality_e2e() {
  _impl_._has_bits_[0] &= ~0x00000020u;
  ::CMsgSteamDatagramConnectionQuality* temp = _impl_.quality_e2e_;
  _impl_.quality_e2e_ = 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 ::CMsgSteamDatagramConnectionQuality* CMsgSteamDatagramConnectionClosed::unsafe_arena_release_quality_e2e() {
  // @@protoc_insertion_point(field_release:CMsgSteamDatagramConnectionClosed.quality_e2e)
  _impl_._has_bits_[0] &= ~0x00000020u;
  ::CMsgSteamDatagramConnectionQuality* temp = _impl_.quality_e2e_;
  _impl_.quality_e2e_ = nullptr;
  return temp;
}
inline ::CMsgSteamDatagramConnectionQuality* CMsgSteamDatagramConnectionClosed::_internal_mutable_quality_e2e() {
  _impl_._has_bits_[0] |= 0x00000020u;
  if (_impl_.quality_e2e_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgSteamDatagramConnectionQuality>(GetArenaForAllocation());
    _impl_.quality_e2e_ = p;
  }
  return _impl_.quality_e2e_;
}
inline ::CMsgSteamDatagramConnectionQuality* CMsgSteamDatagramConnectionClosed::mutable_quality_e2e() {
  ::CMsgSteamDatagramConnectionQuality* _msg = _internal_mutable_quality_e2e();
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramConnectionClosed.quality_e2e)
  return _msg;
}
inline void CMsgSteamDatagramConnectionClosed::set_allocated_quality_e2e(::CMsgSteamDatagramConnectionQuality* quality_e2e) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.quality_e2e_);
  }
  if (quality_e2e) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(quality_e2e));
    if (message_arena != submessage_arena) {
      quality_e2e = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, quality_e2e, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000020u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000020u;
  }
  _impl_.quality_e2e_ = quality_e2e;
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamDatagramConnectionClosed.quality_e2e)
}

// optional .CMsgSteamDatagramP2PRoutingSummary p2p_routing_summary = 21;
inline bool CMsgSteamDatagramConnectionClosed::_internal_has_p2p_routing_summary() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.p2p_routing_summary_ != nullptr);
  return value;
}
inline bool CMsgSteamDatagramConnectionClosed::has_p2p_routing_summary() const {
  return _internal_has_p2p_routing_summary();
}
inline void CMsgSteamDatagramConnectionClosed::clear_p2p_routing_summary() {
  if (_impl_.p2p_routing_summary_ != nullptr) _impl_.p2p_routing_summary_->Clear();
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline const ::CMsgSteamDatagramP2PRoutingSummary& CMsgSteamDatagramConnectionClosed::_internal_p2p_routing_summary() const {
  const ::CMsgSteamDatagramP2PRoutingSummary* p = _impl_.p2p_routing_summary_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgSteamDatagramP2PRoutingSummary&>(
      ::_CMsgSteamDatagramP2PRoutingSummary_default_instance_);
}
inline const ::CMsgSteamDatagramP2PRoutingSummary& CMsgSteamDatagramConnectionClosed::p2p_routing_summary() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectionClosed.p2p_routing_summary)
  return _internal_p2p_routing_summary();
}
inline void CMsgSteamDatagramConnectionClosed::unsafe_arena_set_allocated_p2p_routing_summary(
    ::CMsgSteamDatagramP2PRoutingSummary* p2p_routing_summary) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.p2p_routing_summary_);
  }
  _impl_.p2p_routing_summary_ = p2p_routing_summary;
  if (p2p_routing_summary) {
    _impl_._has_bits_[0] |= 0x00000040u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000040u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgSteamDatagramConnectionClosed.p2p_routing_summary)
}
inline ::CMsgSteamDatagramP2PRoutingSummary* CMsgSteamDatagramConnectionClosed::release_p2p_routing_summary() {
  _impl_._has_bits_[0] &= ~0x00000040u;
  ::CMsgSteamDatagramP2PRoutingSummary* temp = _impl_.p2p_routing_summary_;
  _impl_.p2p_routing_summary_ = 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 ::CMsgSteamDatagramP2PRoutingSummary* CMsgSteamDatagramConnectionClosed::unsafe_arena_release_p2p_routing_summary() {
  // @@protoc_insertion_point(field_release:CMsgSteamDatagramConnectionClosed.p2p_routing_summary)
  _impl_._has_bits_[0] &= ~0x00000040u;
  ::CMsgSteamDatagramP2PRoutingSummary* temp = _impl_.p2p_routing_summary_;
  _impl_.p2p_routing_summary_ = nullptr;
  return temp;
}
inline ::CMsgSteamDatagramP2PRoutingSummary* CMsgSteamDatagramConnectionClosed::_internal_mutable_p2p_routing_summary() {
  _impl_._has_bits_[0] |= 0x00000040u;
  if (_impl_.p2p_routing_summary_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgSteamDatagramP2PRoutingSummary>(GetArenaForAllocation());
    _impl_.p2p_routing_summary_ = p;
  }
  return _impl_.p2p_routing_summary_;
}
inline ::CMsgSteamDatagramP2PRoutingSummary* CMsgSteamDatagramConnectionClosed::mutable_p2p_routing_summary() {
  ::CMsgSteamDatagramP2PRoutingSummary* _msg = _internal_mutable_p2p_routing_summary();
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramConnectionClosed.p2p_routing_summary)
  return _msg;
}
inline void CMsgSteamDatagramConnectionClosed::set_allocated_p2p_routing_summary(::CMsgSteamDatagramP2PRoutingSummary* p2p_routing_summary) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.p2p_routing_summary_;
  }
  if (p2p_routing_summary) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(p2p_routing_summary);
    if (message_arena != submessage_arena) {
      p2p_routing_summary = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, p2p_routing_summary, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000040u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000040u;
  }
  _impl_.p2p_routing_summary_ = p2p_routing_summary;
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamDatagramConnectionClosed.p2p_routing_summary)
}

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

// CMsgSteamDatagramNoConnection

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

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

// optional uint32 legacy_gameserver_relay_session_id = 2;
inline bool CMsgSteamDatagramNoConnection::_internal_has_legacy_gameserver_relay_session_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool CMsgSteamDatagramNoConnection::has_legacy_gameserver_relay_session_id() const {
  return _internal_has_legacy_gameserver_relay_session_id();
}
inline void CMsgSteamDatagramNoConnection::clear_legacy_gameserver_relay_session_id() {
  _impl_.legacy_gameserver_relay_session_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline uint32_t CMsgSteamDatagramNoConnection::_internal_legacy_gameserver_relay_session_id() const {
  return _impl_.legacy_gameserver_relay_session_id_;
}
inline uint32_t CMsgSteamDatagramNoConnection::legacy_gameserver_relay_session_id() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramNoConnection.legacy_gameserver_relay_session_id)
  return _internal_legacy_gameserver_relay_session_id();
}
inline void CMsgSteamDatagramNoConnection::_internal_set_legacy_gameserver_relay_session_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.legacy_gameserver_relay_session_id_ = value;
}
inline void CMsgSteamDatagramNoConnection::set_legacy_gameserver_relay_session_id(uint32_t value) {
  _internal_set_legacy_gameserver_relay_session_id(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramNoConnection.legacy_gameserver_relay_session_id)
}

// optional fixed32 to_relay_session_id = 9;
inline bool CMsgSteamDatagramNoConnection::_internal_has_to_relay_session_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool CMsgSteamDatagramNoConnection::has_to_relay_session_id() const {
  return _internal_has_to_relay_session_id();
}
inline void CMsgSteamDatagramNoConnection::clear_to_relay_session_id() {
  _impl_.to_relay_session_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline uint32_t CMsgSteamDatagramNoConnection::_internal_to_relay_session_id() const {
  return _impl_.to_relay_session_id_;
}
inline uint32_t CMsgSteamDatagramNoConnection::to_relay_session_id() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramNoConnection.to_relay_session_id)
  return _internal_to_relay_session_id();
}
inline void CMsgSteamDatagramNoConnection::_internal_set_to_relay_session_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.to_relay_session_id_ = value;
}
inline void CMsgSteamDatagramNoConnection::set_to_relay_session_id(uint32_t value) {
  _internal_set_to_relay_session_id(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramNoConnection.to_relay_session_id)
}

// optional fixed32 from_relay_session_id = 10;
inline bool CMsgSteamDatagramNoConnection::_internal_has_from_relay_session_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool CMsgSteamDatagramNoConnection::has_from_relay_session_id() const {
  return _internal_has_from_relay_session_id();
}
inline void CMsgSteamDatagramNoConnection::clear_from_relay_session_id() {
  _impl_.from_relay_session_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline uint32_t CMsgSteamDatagramNoConnection::_internal_from_relay_session_id() const {
  return _impl_.from_relay_session_id_;
}
inline uint32_t CMsgSteamDatagramNoConnection::from_relay_session_id() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramNoConnection.from_relay_session_id)
  return _internal_from_relay_session_id();
}
inline void CMsgSteamDatagramNoConnection::_internal_set_from_relay_session_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000400u;
  _impl_.from_relay_session_id_ = value;
}
inline void CMsgSteamDatagramNoConnection::set_from_relay_session_id(uint32_t value) {
  _internal_set_from_relay_session_id(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramNoConnection.from_relay_session_id)
}

// optional string from_identity_string = 7;
inline bool CMsgSteamDatagramNoConnection::_internal_has_from_identity_string() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgSteamDatagramNoConnection::has_from_identity_string() const {
  return _internal_has_from_identity_string();
}
inline void CMsgSteamDatagramNoConnection::clear_from_identity_string() {
  _impl_.from_identity_string_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CMsgSteamDatagramNoConnection::from_identity_string() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramNoConnection.from_identity_string)
  return _internal_from_identity_string();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgSteamDatagramNoConnection::set_from_identity_string(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.from_identity_string_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramNoConnection.from_identity_string)
}
inline std::string* CMsgSteamDatagramNoConnection::mutable_from_identity_string() {
  std::string* _s = _internal_mutable_from_identity_string();
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramNoConnection.from_identity_string)
  return _s;
}
inline const std::string& CMsgSteamDatagramNoConnection::_internal_from_identity_string() const {
  return _impl_.from_identity_string_.Get();
}
inline void CMsgSteamDatagramNoConnection::_internal_set_from_identity_string(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.from_identity_string_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramNoConnection::_internal_mutable_from_identity_string() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.from_identity_string_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramNoConnection::release_from_identity_string() {
  // @@protoc_insertion_point(field_release:CMsgSteamDatagramNoConnection.from_identity_string)
  if (!_internal_has_from_identity_string()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.from_identity_string_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.from_identity_string_.IsDefault()) {
    _impl_.from_identity_string_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgSteamDatagramNoConnection::set_allocated_from_identity_string(std::string* from_identity_string) {
  if (from_identity_string != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.from_identity_string_.SetAllocated(from_identity_string, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.from_identity_string_.IsDefault()) {
    _impl_.from_identity_string_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamDatagramNoConnection.from_identity_string)
}

// optional fixed64 legacy_from_steam_id = 3;
inline bool CMsgSteamDatagramNoConnection::_internal_has_legacy_from_steam_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CMsgSteamDatagramNoConnection::has_legacy_from_steam_id() const {
  return _internal_has_legacy_from_steam_id();
}
inline void CMsgSteamDatagramNoConnection::clear_legacy_from_steam_id() {
  _impl_.legacy_from_steam_id_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline uint64_t CMsgSteamDatagramNoConnection::_internal_legacy_from_steam_id() const {
  return _impl_.legacy_from_steam_id_;
}
inline uint64_t CMsgSteamDatagramNoConnection::legacy_from_steam_id() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramNoConnection.legacy_from_steam_id)
  return _internal_legacy_from_steam_id();
}
inline void CMsgSteamDatagramNoConnection::_internal_set_legacy_from_steam_id(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.legacy_from_steam_id_ = value;
}
inline void CMsgSteamDatagramNoConnection::set_legacy_from_steam_id(uint64_t value) {
  _internal_set_legacy_from_steam_id(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramNoConnection.legacy_from_steam_id)
}

// optional bool end_to_end = 4;
inline bool CMsgSteamDatagramNoConnection::_internal_has_end_to_end() const {
  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
  return value;
}
inline bool CMsgSteamDatagramNoConnection::has_end_to_end() const {
  return _internal_has_end_to_end();
}
inline void CMsgSteamDatagramNoConnection::clear_end_to_end() {
  _impl_.end_to_end_ = false;
  _impl_._has_bits_[0] &= ~0x00000800u;
}
inline bool CMsgSteamDatagramNoConnection::_internal_end_to_end() const {
  return _impl_.end_to_end_;
}
inline bool CMsgSteamDatagramNoConnection::end_to_end() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramNoConnection.end_to_end)
  return _internal_end_to_end();
}
inline void CMsgSteamDatagramNoConnection::_internal_set_end_to_end(bool value) {
  _impl_._has_bits_[0] |= 0x00000800u;
  _impl_.end_to_end_ = value;
}
inline void CMsgSteamDatagramNoConnection::set_end_to_end(bool value) {
  _internal_set_end_to_end(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramNoConnection.end_to_end)
}

// optional bool not_primary_session = 12;
inline bool CMsgSteamDatagramNoConnection::_internal_has_not_primary_session() const {
  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
  return value;
}
inline bool CMsgSteamDatagramNoConnection::has_not_primary_session() const {
  return _internal_has_not_primary_session();
}
inline void CMsgSteamDatagramNoConnection::clear_not_primary_session() {
  _impl_.not_primary_session_ = false;
  _impl_._has_bits_[0] &= ~0x00001000u;
}
inline bool CMsgSteamDatagramNoConnection::_internal_not_primary_session() const {
  return _impl_.not_primary_session_;
}
inline bool CMsgSteamDatagramNoConnection::not_primary_session() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramNoConnection.not_primary_session)
  return _internal_not_primary_session();
}
inline void CMsgSteamDatagramNoConnection::_internal_set_not_primary_session(bool value) {
  _impl_._has_bits_[0] |= 0x00001000u;
  _impl_.not_primary_session_ = value;
}
inline void CMsgSteamDatagramNoConnection::set_not_primary_session(bool value) {
  _internal_set_not_primary_session(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramNoConnection.not_primary_session)
}

// optional bool not_primary_transport = 15;
inline bool CMsgSteamDatagramNoConnection::_internal_has_not_primary_transport() const {
  bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0;
  return value;
}
inline bool CMsgSteamDatagramNoConnection::has_not_primary_transport() const {
  return _internal_has_not_primary_transport();
}
inline void CMsgSteamDatagramNoConnection::clear_not_primary_transport() {
  _impl_.not_primary_transport_ = false;
  _impl_._has_bits_[0] &= ~0x00002000u;
}
inline bool CMsgSteamDatagramNoConnection::_internal_not_primary_transport() const {
  return _impl_.not_primary_transport_;
}
inline bool CMsgSteamDatagramNoConnection::not_primary_transport() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramNoConnection.not_primary_transport)
  return _internal_not_primary_transport();
}
inline void CMsgSteamDatagramNoConnection::_internal_set_not_primary_transport(bool value) {
  _impl_._has_bits_[0] |= 0x00002000u;
  _impl_.not_primary_transport_ = value;
}
inline void CMsgSteamDatagramNoConnection::set_not_primary_transport(bool value) {
  _internal_set_not_primary_transport(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramNoConnection.not_primary_transport)
}

// optional bool relay_override_active = 17;
inline bool CMsgSteamDatagramNoConnection::_internal_has_relay_override_active() const {
  bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0;
  return value;
}
inline bool CMsgSteamDatagramNoConnection::has_relay_override_active() const {
  return _internal_has_relay_override_active();
}
inline void CMsgSteamDatagramNoConnection::clear_relay_override_active() {
  _impl_.relay_override_active_ = false;
  _impl_._has_bits_[0] &= ~0x00004000u;
}
inline bool CMsgSteamDatagramNoConnection::_internal_relay_override_active() const {
  return _impl_.relay_override_active_;
}
inline bool CMsgSteamDatagramNoConnection::relay_override_active() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramNoConnection.relay_override_active)
  return _internal_relay_override_active();
}
inline void CMsgSteamDatagramNoConnection::_internal_set_relay_override_active(bool value) {
  _impl_._has_bits_[0] |= 0x00004000u;
  _impl_.relay_override_active_ = value;
}
inline void CMsgSteamDatagramNoConnection::set_relay_override_active(bool value) {
  _internal_set_relay_override_active(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramNoConnection.relay_override_active)
}

// optional .CMsgSteamDatagramConnectionQuality quality_relay = 13;
inline bool CMsgSteamDatagramNoConnection::_internal_has_quality_relay() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.quality_relay_ != nullptr);
  return value;
}
inline bool CMsgSteamDatagramNoConnection::has_quality_relay() const {
  return _internal_has_quality_relay();
}
inline const ::CMsgSteamDatagramConnectionQuality& CMsgSteamDatagramNoConnection::_internal_quality_relay() const {
  const ::CMsgSteamDatagramConnectionQuality* p = _impl_.quality_relay_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgSteamDatagramConnectionQuality&>(
      ::_CMsgSteamDatagramConnectionQuality_default_instance_);
}
inline const ::CMsgSteamDatagramConnectionQuality& CMsgSteamDatagramNoConnection::quality_relay() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramNoConnection.quality_relay)
  return _internal_quality_relay();
}
inline void CMsgSteamDatagramNoConnection::unsafe_arena_set_allocated_quality_relay(
    ::CMsgSteamDatagramConnectionQuality* quality_relay) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.quality_relay_);
  }
  _impl_.quality_relay_ = quality_relay;
  if (quality_relay) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgSteamDatagramNoConnection.quality_relay)
}
inline ::CMsgSteamDatagramConnectionQuality* CMsgSteamDatagramNoConnection::release_quality_relay() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgSteamDatagramConnectionQuality* temp = _impl_.quality_relay_;
  _impl_.quality_relay_ = 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 ::CMsgSteamDatagramConnectionQuality* CMsgSteamDatagramNoConnection::unsafe_arena_release_quality_relay() {
  // @@protoc_insertion_point(field_release:CMsgSteamDatagramNoConnection.quality_relay)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgSteamDatagramConnectionQuality* temp = _impl_.quality_relay_;
  _impl_.quality_relay_ = nullptr;
  return temp;
}
inline ::CMsgSteamDatagramConnectionQuality* CMsgSteamDatagramNoConnection::_internal_mutable_quality_relay() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.quality_relay_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgSteamDatagramConnectionQuality>(GetArenaForAllocation());
    _impl_.quality_relay_ = p;
  }
  return _impl_.quality_relay_;
}
inline ::CMsgSteamDatagramConnectionQuality* CMsgSteamDatagramNoConnection::mutable_quality_relay() {
  ::CMsgSteamDatagramConnectionQuality* _msg = _internal_mutable_quality_relay();
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramNoConnection.quality_relay)
  return _msg;
}
inline void CMsgSteamDatagramNoConnection::set_allocated_quality_relay(::CMsgSteamDatagramConnectionQuality* quality_relay) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.quality_relay_);
  }
  if (quality_relay) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(quality_relay));
    if (message_arena != submessage_arena) {
      quality_relay = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, quality_relay, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.quality_relay_ = quality_relay;
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamDatagramNoConnection.quality_relay)
}

// optional .CMsgSteamDatagramConnectionQuality quality_e2e = 14;
inline bool CMsgSteamDatagramNoConnection::_internal_has_quality_e2e() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.quality_e2e_ != nullptr);
  return value;
}
inline bool CMsgSteamDatagramNoConnection::has_quality_e2e() const {
  return _internal_has_quality_e2e();
}
inline const ::CMsgSteamDatagramConnectionQuality& CMsgSteamDatagramNoConnection::_internal_quality_e2e() const {
  const ::CMsgSteamDatagramConnectionQuality* p = _impl_.quality_e2e_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgSteamDatagramConnectionQuality&>(
      ::_CMsgSteamDatagramConnectionQuality_default_instance_);
}
inline const ::CMsgSteamDatagramConnectionQuality& CMsgSteamDatagramNoConnection::quality_e2e() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramNoConnection.quality_e2e)
  return _internal_quality_e2e();
}
inline void CMsgSteamDatagramNoConnection::unsafe_arena_set_allocated_quality_e2e(
    ::CMsgSteamDatagramConnectionQuality* quality_e2e) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.quality_e2e_);
  }
  _impl_.quality_e2e_ = quality_e2e;
  if (quality_e2e) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgSteamDatagramNoConnection.quality_e2e)
}
inline ::CMsgSteamDatagramConnectionQuality* CMsgSteamDatagramNoConnection::release_quality_e2e() {
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::CMsgSteamDatagramConnectionQuality* temp = _impl_.quality_e2e_;
  _impl_.quality_e2e_ = 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 ::CMsgSteamDatagramConnectionQuality* CMsgSteamDatagramNoConnection::unsafe_arena_release_quality_e2e() {
  // @@protoc_insertion_point(field_release:CMsgSteamDatagramNoConnection.quality_e2e)
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::CMsgSteamDatagramConnectionQuality* temp = _impl_.quality_e2e_;
  _impl_.quality_e2e_ = nullptr;
  return temp;
}
inline ::CMsgSteamDatagramConnectionQuality* CMsgSteamDatagramNoConnection::_internal_mutable_quality_e2e() {
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.quality_e2e_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgSteamDatagramConnectionQuality>(GetArenaForAllocation());
    _impl_.quality_e2e_ = p;
  }
  return _impl_.quality_e2e_;
}
inline ::CMsgSteamDatagramConnectionQuality* CMsgSteamDatagramNoConnection::mutable_quality_e2e() {
  ::CMsgSteamDatagramConnectionQuality* _msg = _internal_mutable_quality_e2e();
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramNoConnection.quality_e2e)
  return _msg;
}
inline void CMsgSteamDatagramNoConnection::set_allocated_quality_e2e(::CMsgSteamDatagramConnectionQuality* quality_e2e) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.quality_e2e_);
  }
  if (quality_e2e) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(quality_e2e));
    if (message_arena != submessage_arena) {
      quality_e2e = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, quality_e2e, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.quality_e2e_ = quality_e2e;
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamDatagramNoConnection.quality_e2e)
}

// optional .CMsgSteamDatagramP2PRoutingSummary p2p_routing_summary = 16;
inline bool CMsgSteamDatagramNoConnection::_internal_has_p2p_routing_summary() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.p2p_routing_summary_ != nullptr);
  return value;
}
inline bool CMsgSteamDatagramNoConnection::has_p2p_routing_summary() const {
  return _internal_has_p2p_routing_summary();
}
inline void CMsgSteamDatagramNoConnection::clear_p2p_routing_summary() {
  if (_impl_.p2p_routing_summary_ != nullptr) _impl_.p2p_routing_summary_->Clear();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const ::CMsgSteamDatagramP2PRoutingSummary& CMsgSteamDatagramNoConnection::_internal_p2p_routing_summary() const {
  const ::CMsgSteamDatagramP2PRoutingSummary* p = _impl_.p2p_routing_summary_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgSteamDatagramP2PRoutingSummary&>(
      ::_CMsgSteamDatagramP2PRoutingSummary_default_instance_);
}
inline const ::CMsgSteamDatagramP2PRoutingSummary& CMsgSteamDatagramNoConnection::p2p_routing_summary() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramNoConnection.p2p_routing_summary)
  return _internal_p2p_routing_summary();
}
inline void CMsgSteamDatagramNoConnection::unsafe_arena_set_allocated_p2p_routing_summary(
    ::CMsgSteamDatagramP2PRoutingSummary* p2p_routing_summary) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.p2p_routing_summary_);
  }
  _impl_.p2p_routing_summary_ = p2p_routing_summary;
  if (p2p_routing_summary) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgSteamDatagramNoConnection.p2p_routing_summary)
}
inline ::CMsgSteamDatagramP2PRoutingSummary* CMsgSteamDatagramNoConnection::release_p2p_routing_summary() {
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::CMsgSteamDatagramP2PRoutingSummary* temp = _impl_.p2p_routing_summary_;
  _impl_.p2p_routing_summary_ = 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 ::CMsgSteamDatagramP2PRoutingSummary* CMsgSteamDatagramNoConnection::unsafe_arena_release_p2p_routing_summary() {
  // @@protoc_insertion_point(field_release:CMsgSteamDatagramNoConnection.p2p_routing_summary)
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::CMsgSteamDatagramP2PRoutingSummary* temp = _impl_.p2p_routing_summary_;
  _impl_.p2p_routing_summary_ = nullptr;
  return temp;
}
inline ::CMsgSteamDatagramP2PRoutingSummary* CMsgSteamDatagramNoConnection::_internal_mutable_p2p_routing_summary() {
  _impl_._has_bits_[0] |= 0x00000008u;
  if (_impl_.p2p_routing_summary_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgSteamDatagramP2PRoutingSummary>(GetArenaForAllocation());
    _impl_.p2p_routing_summary_ = p;
  }
  return _impl_.p2p_routing_summary_;
}
inline ::CMsgSteamDatagramP2PRoutingSummary* CMsgSteamDatagramNoConnection::mutable_p2p_routing_summary() {
  ::CMsgSteamDatagramP2PRoutingSummary* _msg = _internal_mutable_p2p_routing_summary();
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramNoConnection.p2p_routing_summary)
  return _msg;
}
inline void CMsgSteamDatagramNoConnection::set_allocated_p2p_routing_summary(::CMsgSteamDatagramP2PRoutingSummary* p2p_routing_summary) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.p2p_routing_summary_;
  }
  if (p2p_routing_summary) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(p2p_routing_summary);
    if (message_arena != submessage_arena) {
      p2p_routing_summary = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, p2p_routing_summary, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.p2p_routing_summary_ = p2p_routing_summary;
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamDatagramNoConnection.p2p_routing_summary)
}

// optional fixed64 routing_secret = 11;
inline bool CMsgSteamDatagramNoConnection::_internal_has_routing_secret() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool CMsgSteamDatagramNoConnection::has_routing_secret() const {
  return _internal_has_routing_secret();
}
inline void CMsgSteamDatagramNoConnection::clear_routing_secret() {
  _impl_.routing_secret_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline uint64_t CMsgSteamDatagramNoConnection::_internal_routing_secret() const {
  return _impl_.routing_secret_;
}
inline uint64_t CMsgSteamDatagramNoConnection::routing_secret() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramNoConnection.routing_secret)
  return _internal_routing_secret();
}
inline void CMsgSteamDatagramNoConnection::_internal_set_routing_secret(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.routing_secret_ = value;
}
inline void CMsgSteamDatagramNoConnection::set_routing_secret(uint64_t value) {
  _internal_set_routing_secret(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramNoConnection.routing_secret)
}

// optional fixed32 dummy_pad = 1023;
inline bool CMsgSteamDatagramNoConnection::_internal_has_dummy_pad() const {
  bool value = (_impl_._has_bits_[0] & 0x00008000u) != 0;
  return value;
}
inline bool CMsgSteamDatagramNoConnection::has_dummy_pad() const {
  return _internal_has_dummy_pad();
}
inline void CMsgSteamDatagramNoConnection::clear_dummy_pad() {
  _impl_.dummy_pad_ = 0u;
  _impl_._has_bits_[0] &= ~0x00008000u;
}
inline uint32_t CMsgSteamDatagramNoConnection::_internal_dummy_pad() const {
  return _impl_.dummy_pad_;
}
inline uint32_t CMsgSteamDatagramNoConnection::dummy_pad() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramNoConnection.dummy_pad)
  return _internal_dummy_pad();
}
inline void CMsgSteamDatagramNoConnection::_internal_set_dummy_pad(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00008000u;
  _impl_.dummy_pad_ = value;
}
inline void CMsgSteamDatagramNoConnection::set_dummy_pad(uint32_t value) {
  _internal_set_dummy_pad(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramNoConnection.dummy_pad)
}

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

// CMsgSteamDatagramGameserverSessionRequest

// optional bytes ticket = 1;
inline bool CMsgSteamDatagramGameserverSessionRequest::_internal_has_ticket() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgSteamDatagramGameserverSessionRequest::has_ticket() const {
  return _internal_has_ticket();
}
inline void CMsgSteamDatagramGameserverSessionRequest::clear_ticket() {
  _impl_.ticket_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CMsgSteamDatagramGameserverSessionRequest::ticket() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramGameserverSessionRequest.ticket)
  return _internal_ticket();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgSteamDatagramGameserverSessionRequest::set_ticket(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.ticket_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramGameserverSessionRequest.ticket)
}
inline std::string* CMsgSteamDatagramGameserverSessionRequest::mutable_ticket() {
  std::string* _s = _internal_mutable_ticket();
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramGameserverSessionRequest.ticket)
  return _s;
}
inline const std::string& CMsgSteamDatagramGameserverSessionRequest::_internal_ticket() const {
  return _impl_.ticket_.Get();
}
inline void CMsgSteamDatagramGameserverSessionRequest::_internal_set_ticket(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.ticket_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramGameserverSessionRequest::_internal_mutable_ticket() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.ticket_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramGameserverSessionRequest::release_ticket() {
  // @@protoc_insertion_point(field_release:CMsgSteamDatagramGameserverSessionRequest.ticket)
  if (!_internal_has_ticket()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.ticket_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.ticket_.IsDefault()) {
    _impl_.ticket_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgSteamDatagramGameserverSessionRequest::set_allocated_ticket(std::string* ticket) {
  if (ticket != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.ticket_.SetAllocated(ticket, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.ticket_.IsDefault()) {
    _impl_.ticket_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamDatagramGameserverSessionRequest.ticket)
}

// optional fixed32 challenge_time = 3;
inline bool CMsgSteamDatagramGameserverSessionRequest::_internal_has_challenge_time() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool CMsgSteamDatagramGameserverSessionRequest::has_challenge_time() const {
  return _internal_has_challenge_time();
}
inline void CMsgSteamDatagramGameserverSessionRequest::clear_challenge_time() {
  _impl_.challenge_time_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline uint32_t CMsgSteamDatagramGameserverSessionRequest::_internal_challenge_time() const {
  return _impl_.challenge_time_;
}
inline uint32_t CMsgSteamDatagramGameserverSessionRequest::challenge_time() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramGameserverSessionRequest.challenge_time)
  return _internal_challenge_time();
}
inline void CMsgSteamDatagramGameserverSessionRequest::_internal_set_challenge_time(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.challenge_time_ = value;
}
inline void CMsgSteamDatagramGameserverSessionRequest::set_challenge_time(uint32_t value) {
  _internal_set_challenge_time(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramGameserverSessionRequest.challenge_time)
}

// optional fixed64 challenge = 4;
inline bool CMsgSteamDatagramGameserverSessionRequest::_internal_has_challenge() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool CMsgSteamDatagramGameserverSessionRequest::has_challenge() const {
  return _internal_has_challenge();
}
inline void CMsgSteamDatagramGameserverSessionRequest::clear_challenge() {
  _impl_.challenge_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline uint64_t CMsgSteamDatagramGameserverSessionRequest::_internal_challenge() const {
  return _impl_.challenge_;
}
inline uint64_t CMsgSteamDatagramGameserverSessionRequest::challenge() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramGameserverSessionRequest.challenge)
  return _internal_challenge();
}
inline void CMsgSteamDatagramGameserverSessionRequest::_internal_set_challenge(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.challenge_ = value;
}
inline void CMsgSteamDatagramGameserverSessionRequest::set_challenge(uint64_t value) {
  _internal_set_challenge(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramGameserverSessionRequest.challenge)
}

// optional fixed32 client_connection_id = 5;
inline bool CMsgSteamDatagramGameserverSessionRequest::_internal_has_client_connection_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool CMsgSteamDatagramGameserverSessionRequest::has_client_connection_id() const {
  return _internal_has_client_connection_id();
}
inline void CMsgSteamDatagramGameserverSessionRequest::clear_client_connection_id() {
  _impl_.client_connection_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline uint32_t CMsgSteamDatagramGameserverSessionRequest::_internal_client_connection_id() const {
  return _impl_.client_connection_id_;
}
inline uint32_t CMsgSteamDatagramGameserverSessionRequest::client_connection_id() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramGameserverSessionRequest.client_connection_id)
  return _internal_client_connection_id();
}
inline void CMsgSteamDatagramGameserverSessionRequest::_internal_set_client_connection_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.client_connection_id_ = value;
}
inline void CMsgSteamDatagramGameserverSessionRequest::set_client_connection_id(uint32_t value) {
  _internal_set_client_connection_id(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramGameserverSessionRequest.client_connection_id)
}

// optional fixed32 server_connection_id = 8;
inline bool CMsgSteamDatagramGameserverSessionRequest::_internal_has_server_connection_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool CMsgSteamDatagramGameserverSessionRequest::has_server_connection_id() const {
  return _internal_has_server_connection_id();
}
inline void CMsgSteamDatagramGameserverSessionRequest::clear_server_connection_id() {
  _impl_.server_connection_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline uint32_t CMsgSteamDatagramGameserverSessionRequest::_internal_server_connection_id() const {
  return _impl_.server_connection_id_;
}
inline uint32_t CMsgSteamDatagramGameserverSessionRequest::server_connection_id() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramGameserverSessionRequest.server_connection_id)
  return _internal_server_connection_id();
}
inline void CMsgSteamDatagramGameserverSessionRequest::_internal_set_server_connection_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000400u;
  _impl_.server_connection_id_ = value;
}
inline void CMsgSteamDatagramGameserverSessionRequest::set_server_connection_id(uint32_t value) {
  _internal_set_server_connection_id(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramGameserverSessionRequest.server_connection_id)
}

// optional uint64 network_config_version = 6;
inline bool CMsgSteamDatagramGameserverSessionRequest::_internal_has_network_config_version() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool CMsgSteamDatagramGameserverSessionRequest::has_network_config_version() const {
  return _internal_has_network_config_version();
}
inline void CMsgSteamDatagramGameserverSessionRequest::clear_network_config_version() {
  _impl_.network_config_version_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline uint64_t CMsgSteamDatagramGameserverSessionRequest::_internal_network_config_version() const {
  return _impl_.network_config_version_;
}
inline uint64_t CMsgSteamDatagramGameserverSessionRequest::network_config_version() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramGameserverSessionRequest.network_config_version)
  return _internal_network_config_version();
}
inline void CMsgSteamDatagramGameserverSessionRequest::_internal_set_network_config_version(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.network_config_version_ = value;
}
inline void CMsgSteamDatagramGameserverSessionRequest::set_network_config_version(uint64_t value) {
  _internal_set_network_config_version(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramGameserverSessionRequest.network_config_version)
}

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

// optional string platform = 9;
inline bool CMsgSteamDatagramGameserverSessionRequest::_internal_has_platform() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgSteamDatagramGameserverSessionRequest::has_platform() const {
  return _internal_has_platform();
}
inline void CMsgSteamDatagramGameserverSessionRequest::clear_platform() {
  _impl_.platform_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& CMsgSteamDatagramGameserverSessionRequest::platform() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramGameserverSessionRequest.platform)
  return _internal_platform();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgSteamDatagramGameserverSessionRequest::set_platform(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.platform_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramGameserverSessionRequest.platform)
}
inline std::string* CMsgSteamDatagramGameserverSessionRequest::mutable_platform() {
  std::string* _s = _internal_mutable_platform();
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramGameserverSessionRequest.platform)
  return _s;
}
inline const std::string& CMsgSteamDatagramGameserverSessionRequest::_internal_platform() const {
  return _impl_.platform_.Get();
}
inline void CMsgSteamDatagramGameserverSessionRequest::_internal_set_platform(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.platform_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramGameserverSessionRequest::_internal_mutable_platform() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.platform_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramGameserverSessionRequest::release_platform() {
  // @@protoc_insertion_point(field_release:CMsgSteamDatagramGameserverSessionRequest.platform)
  if (!_internal_has_platform()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.platform_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.platform_.IsDefault()) {
    _impl_.platform_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgSteamDatagramGameserverSessionRequest::set_allocated_platform(std::string* platform) {
  if (platform != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.platform_.SetAllocated(platform, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.platform_.IsDefault()) {
    _impl_.platform_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamDatagramGameserverSessionRequest.platform)
}

// optional string build = 10;
inline bool CMsgSteamDatagramGameserverSessionRequest::_internal_has_build() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgSteamDatagramGameserverSessionRequest::has_build() const {
  return _internal_has_build();
}
inline void CMsgSteamDatagramGameserverSessionRequest::clear_build() {
  _impl_.build_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& CMsgSteamDatagramGameserverSessionRequest::build() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramGameserverSessionRequest.build)
  return _internal_build();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgSteamDatagramGameserverSessionRequest::set_build(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.build_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramGameserverSessionRequest.build)
}
inline std::string* CMsgSteamDatagramGameserverSessionRequest::mutable_build() {
  std::string* _s = _internal_mutable_build();
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramGameserverSessionRequest.build)
  return _s;
}
inline const std::string& CMsgSteamDatagramGameserverSessionRequest::_internal_build() const {
  return _impl_.build_.Get();
}
inline void CMsgSteamDatagramGameserverSessionRequest::_internal_set_build(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.build_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramGameserverSessionRequest::_internal_mutable_build() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.build_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramGameserverSessionRequest::release_build() {
  // @@protoc_insertion_point(field_release:CMsgSteamDatagramGameserverSessionRequest.build)
  if (!_internal_has_build()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* p = _impl_.build_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.build_.IsDefault()) {
    _impl_.build_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgSteamDatagramGameserverSessionRequest::set_allocated_build(std::string* build) {
  if (build != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.build_.SetAllocated(build, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.build_.IsDefault()) {
    _impl_.build_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamDatagramGameserverSessionRequest.build)
}

// optional string dev_gameserver_identity = 100;
inline bool CMsgSteamDatagramGameserverSessionRequest::_internal_has_dev_gameserver_identity() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CMsgSteamDatagramGameserverSessionRequest::has_dev_gameserver_identity() const {
  return _internal_has_dev_gameserver_identity();
}
inline void CMsgSteamDatagramGameserverSessionRequest::clear_dev_gameserver_identity() {
  _impl_.dev_gameserver_identity_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const std::string& CMsgSteamDatagramGameserverSessionRequest::dev_gameserver_identity() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramGameserverSessionRequest.dev_gameserver_identity)
  return _internal_dev_gameserver_identity();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgSteamDatagramGameserverSessionRequest::set_dev_gameserver_identity(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000008u;
 _impl_.dev_gameserver_identity_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramGameserverSessionRequest.dev_gameserver_identity)
}
inline std::string* CMsgSteamDatagramGameserverSessionRequest::mutable_dev_gameserver_identity() {
  std::string* _s = _internal_mutable_dev_gameserver_identity();
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramGameserverSessionRequest.dev_gameserver_identity)
  return _s;
}
inline const std::string& CMsgSteamDatagramGameserverSessionRequest::_internal_dev_gameserver_identity() const {
  return _impl_.dev_gameserver_identity_.Get();
}
inline void CMsgSteamDatagramGameserverSessionRequest::_internal_set_dev_gameserver_identity(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.dev_gameserver_identity_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramGameserverSessionRequest::_internal_mutable_dev_gameserver_identity() {
  _impl_._has_bits_[0] |= 0x00000008u;
  return _impl_.dev_gameserver_identity_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramGameserverSessionRequest::release_dev_gameserver_identity() {
  // @@protoc_insertion_point(field_release:CMsgSteamDatagramGameserverSessionRequest.dev_gameserver_identity)
  if (!_internal_has_dev_gameserver_identity()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000008u;
  auto* p = _impl_.dev_gameserver_identity_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.dev_gameserver_identity_.IsDefault()) {
    _impl_.dev_gameserver_identity_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgSteamDatagramGameserverSessionRequest::set_allocated_dev_gameserver_identity(std::string* dev_gameserver_identity) {
  if (dev_gameserver_identity != nullptr) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.dev_gameserver_identity_.SetAllocated(dev_gameserver_identity, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.dev_gameserver_identity_.IsDefault()) {
    _impl_.dev_gameserver_identity_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamDatagramGameserverSessionRequest.dev_gameserver_identity)
}

// optional .CMsgSteamDatagramCertificateSigned dev_client_cert = 101;
inline bool CMsgSteamDatagramGameserverSessionRequest::_internal_has_dev_client_cert() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.dev_client_cert_ != nullptr);
  return value;
}
inline bool CMsgSteamDatagramGameserverSessionRequest::has_dev_client_cert() const {
  return _internal_has_dev_client_cert();
}
inline const ::CMsgSteamDatagramCertificateSigned& CMsgSteamDatagramGameserverSessionRequest::_internal_dev_client_cert() const {
  const ::CMsgSteamDatagramCertificateSigned* p = _impl_.dev_client_cert_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgSteamDatagramCertificateSigned&>(
      ::_CMsgSteamDatagramCertificateSigned_default_instance_);
}
inline const ::CMsgSteamDatagramCertificateSigned& CMsgSteamDatagramGameserverSessionRequest::dev_client_cert() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramGameserverSessionRequest.dev_client_cert)
  return _internal_dev_client_cert();
}
inline void CMsgSteamDatagramGameserverSessionRequest::unsafe_arena_set_allocated_dev_client_cert(
    ::CMsgSteamDatagramCertificateSigned* dev_client_cert) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.dev_client_cert_);
  }
  _impl_.dev_client_cert_ = dev_client_cert;
  if (dev_client_cert) {
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgSteamDatagramGameserverSessionRequest.dev_client_cert)
}
inline ::CMsgSteamDatagramCertificateSigned* CMsgSteamDatagramGameserverSessionRequest::release_dev_client_cert() {
  _impl_._has_bits_[0] &= ~0x00000010u;
  ::CMsgSteamDatagramCertificateSigned* temp = _impl_.dev_client_cert_;
  _impl_.dev_client_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* CMsgSteamDatagramGameserverSessionRequest::unsafe_arena_release_dev_client_cert() {
  // @@protoc_insertion_point(field_release:CMsgSteamDatagramGameserverSessionRequest.dev_client_cert)
  _impl_._has_bits_[0] &= ~0x00000010u;
  ::CMsgSteamDatagramCertificateSigned* temp = _impl_.dev_client_cert_;
  _impl_.dev_client_cert_ = nullptr;
  return temp;
}
inline ::CMsgSteamDatagramCertificateSigned* CMsgSteamDatagramGameserverSessionRequest::_internal_mutable_dev_client_cert() {
  _impl_._has_bits_[0] |= 0x00000010u;
  if (_impl_.dev_client_cert_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgSteamDatagramCertificateSigned>(GetArenaForAllocation());
    _impl_.dev_client_cert_ = p;
  }
  return _impl_.dev_client_cert_;
}
inline ::CMsgSteamDatagramCertificateSigned* CMsgSteamDatagramGameserverSessionRequest::mutable_dev_client_cert() {
  ::CMsgSteamDatagramCertificateSigned* _msg = _internal_mutable_dev_client_cert();
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramGameserverSessionRequest.dev_client_cert)
  return _msg;
}
inline void CMsgSteamDatagramGameserverSessionRequest::set_allocated_dev_client_cert(::CMsgSteamDatagramCertificateSigned* dev_client_cert) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.dev_client_cert_);
  }
  if (dev_client_cert) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(dev_client_cert));
    if (message_arena != submessage_arena) {
      dev_client_cert = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, dev_client_cert, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  _impl_.dev_client_cert_ = dev_client_cert;
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamDatagramGameserverSessionRequest.dev_client_cert)
}

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

// CMsgSteamDatagramGameserverSessionEstablished

// optional fixed32 connection_id = 1;
inline bool CMsgSteamDatagramGameserverSessionEstablished::_internal_has_connection_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgSteamDatagramGameserverSessionEstablished::has_connection_id() const {
  return _internal_has_connection_id();
}
inline void CMsgSteamDatagramGameserverSessionEstablished::clear_connection_id() {
  _impl_.connection_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t CMsgSteamDatagramGameserverSessionEstablished::_internal_connection_id() const {
  return _impl_.connection_id_;
}
inline uint32_t CMsgSteamDatagramGameserverSessionEstablished::connection_id() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramGameserverSessionEstablished.connection_id)
  return _internal_connection_id();
}
inline void CMsgSteamDatagramGameserverSessionEstablished::_internal_set_connection_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.connection_id_ = value;
}
inline void CMsgSteamDatagramGameserverSessionEstablished::set_connection_id(uint32_t value) {
  _internal_set_connection_id(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramGameserverSessionEstablished.connection_id)
}

// optional string gameserver_identity_string = 2;
inline bool CMsgSteamDatagramGameserverSessionEstablished::_internal_has_gameserver_identity_string() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgSteamDatagramGameserverSessionEstablished::has_gameserver_identity_string() const {
  return _internal_has_gameserver_identity_string();
}
inline void CMsgSteamDatagramGameserverSessionEstablished::clear_gameserver_identity_string() {
  _impl_.gameserver_identity_string_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CMsgSteamDatagramGameserverSessionEstablished::gameserver_identity_string() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramGameserverSessionEstablished.gameserver_identity_string)
  return _internal_gameserver_identity_string();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgSteamDatagramGameserverSessionEstablished::set_gameserver_identity_string(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.gameserver_identity_string_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramGameserverSessionEstablished.gameserver_identity_string)
}
inline std::string* CMsgSteamDatagramGameserverSessionEstablished::mutable_gameserver_identity_string() {
  std::string* _s = _internal_mutable_gameserver_identity_string();
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramGameserverSessionEstablished.gameserver_identity_string)
  return _s;
}
inline const std::string& CMsgSteamDatagramGameserverSessionEstablished::_internal_gameserver_identity_string() const {
  return _impl_.gameserver_identity_string_.Get();
}
inline void CMsgSteamDatagramGameserverSessionEstablished::_internal_set_gameserver_identity_string(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.gameserver_identity_string_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramGameserverSessionEstablished::_internal_mutable_gameserver_identity_string() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.gameserver_identity_string_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramGameserverSessionEstablished::release_gameserver_identity_string() {
  // @@protoc_insertion_point(field_release:CMsgSteamDatagramGameserverSessionEstablished.gameserver_identity_string)
  if (!_internal_has_gameserver_identity_string()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.gameserver_identity_string_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.gameserver_identity_string_.IsDefault()) {
    _impl_.gameserver_identity_string_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgSteamDatagramGameserverSessionEstablished::set_allocated_gameserver_identity_string(std::string* gameserver_identity_string) {
  if (gameserver_identity_string != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.gameserver_identity_string_.SetAllocated(gameserver_identity_string, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.gameserver_identity_string_.IsDefault()) {
    _impl_.gameserver_identity_string_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamDatagramGameserverSessionEstablished.gameserver_identity_string)
}

// optional uint32 seconds_until_shutdown = 4;
inline bool CMsgSteamDatagramGameserverSessionEstablished::_internal_has_seconds_until_shutdown() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CMsgSteamDatagramGameserverSessionEstablished::has_seconds_until_shutdown() const {
  return _internal_has_seconds_until_shutdown();
}
inline void CMsgSteamDatagramGameserverSessionEstablished::clear_seconds_until_shutdown() {
  _impl_.seconds_until_shutdown_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t CMsgSteamDatagramGameserverSessionEstablished::_internal_seconds_until_shutdown() const {
  return _impl_.seconds_until_shutdown_;
}
inline uint32_t CMsgSteamDatagramGameserverSessionEstablished::seconds_until_shutdown() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramGameserverSessionEstablished.seconds_until_shutdown)
  return _internal_seconds_until_shutdown();
}
inline void CMsgSteamDatagramGameserverSessionEstablished::_internal_set_seconds_until_shutdown(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.seconds_until_shutdown_ = value;
}
inline void CMsgSteamDatagramGameserverSessionEstablished::set_seconds_until_shutdown(uint32_t value) {
  _internal_set_seconds_until_shutdown(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramGameserverSessionEstablished.seconds_until_shutdown)
}

// optional uint32 seq_num_r2c = 6;
inline bool CMsgSteamDatagramGameserverSessionEstablished::_internal_has_seq_num_r2c() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool CMsgSteamDatagramGameserverSessionEstablished::has_seq_num_r2c() const {
  return _internal_has_seq_num_r2c();
}
inline void CMsgSteamDatagramGameserverSessionEstablished::clear_seq_num_r2c() {
  _impl_.seq_num_r2c_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline uint32_t CMsgSteamDatagramGameserverSessionEstablished::_internal_seq_num_r2c() const {
  return _impl_.seq_num_r2c_;
}
inline uint32_t CMsgSteamDatagramGameserverSessionEstablished::seq_num_r2c() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramGameserverSessionEstablished.seq_num_r2c)
  return _internal_seq_num_r2c();
}
inline void CMsgSteamDatagramGameserverSessionEstablished::_internal_set_seq_num_r2c(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.seq_num_r2c_ = value;
}
inline void CMsgSteamDatagramGameserverSessionEstablished::set_seq_num_r2c(uint32_t value) {
  _internal_set_seq_num_r2c(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramGameserverSessionEstablished.seq_num_r2c)
}

// optional bytes dummy_legacy_identity_binary = 7;
inline bool CMsgSteamDatagramGameserverSessionEstablished::_internal_has_dummy_legacy_identity_binary() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgSteamDatagramGameserverSessionEstablished::has_dummy_legacy_identity_binary() const {
  return _internal_has_dummy_legacy_identity_binary();
}
inline void CMsgSteamDatagramGameserverSessionEstablished::clear_dummy_legacy_identity_binary() {
  _impl_.dummy_legacy_identity_binary_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& CMsgSteamDatagramGameserverSessionEstablished::dummy_legacy_identity_binary() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramGameserverSessionEstablished.dummy_legacy_identity_binary)
  return _internal_dummy_legacy_identity_binary();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgSteamDatagramGameserverSessionEstablished::set_dummy_legacy_identity_binary(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.dummy_legacy_identity_binary_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramGameserverSessionEstablished.dummy_legacy_identity_binary)
}
inline std::string* CMsgSteamDatagramGameserverSessionEstablished::mutable_dummy_legacy_identity_binary() {
  std::string* _s = _internal_mutable_dummy_legacy_identity_binary();
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramGameserverSessionEstablished.dummy_legacy_identity_binary)
  return _s;
}
inline const std::string& CMsgSteamDatagramGameserverSessionEstablished::_internal_dummy_legacy_identity_binary() const {
  return _impl_.dummy_legacy_identity_binary_.Get();
}
inline void CMsgSteamDatagramGameserverSessionEstablished::_internal_set_dummy_legacy_identity_binary(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.dummy_legacy_identity_binary_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramGameserverSessionEstablished::_internal_mutable_dummy_legacy_identity_binary() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.dummy_legacy_identity_binary_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramGameserverSessionEstablished::release_dummy_legacy_identity_binary() {
  // @@protoc_insertion_point(field_release:CMsgSteamDatagramGameserverSessionEstablished.dummy_legacy_identity_binary)
  if (!_internal_has_dummy_legacy_identity_binary()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.dummy_legacy_identity_binary_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.dummy_legacy_identity_binary_.IsDefault()) {
    _impl_.dummy_legacy_identity_binary_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgSteamDatagramGameserverSessionEstablished::set_allocated_dummy_legacy_identity_binary(std::string* dummy_legacy_identity_binary) {
  if (dummy_legacy_identity_binary != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.dummy_legacy_identity_binary_.SetAllocated(dummy_legacy_identity_binary, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.dummy_legacy_identity_binary_.IsDefault()) {
    _impl_.dummy_legacy_identity_binary_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamDatagramGameserverSessionEstablished.dummy_legacy_identity_binary)
}

// optional fixed64 legacy_gameserver_steamid = 3;
inline bool CMsgSteamDatagramGameserverSessionEstablished::_internal_has_legacy_gameserver_steamid() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CMsgSteamDatagramGameserverSessionEstablished::has_legacy_gameserver_steamid() const {
  return _internal_has_legacy_gameserver_steamid();
}
inline void CMsgSteamDatagramGameserverSessionEstablished::clear_legacy_gameserver_steamid() {
  _impl_.legacy_gameserver_steamid_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline uint64_t CMsgSteamDatagramGameserverSessionEstablished::_internal_legacy_gameserver_steamid() const {
  return _impl_.legacy_gameserver_steamid_;
}
inline uint64_t CMsgSteamDatagramGameserverSessionEstablished::legacy_gameserver_steamid() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramGameserverSessionEstablished.legacy_gameserver_steamid)
  return _internal_legacy_gameserver_steamid();
}
inline void CMsgSteamDatagramGameserverSessionEstablished::_internal_set_legacy_gameserver_steamid(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.legacy_gameserver_steamid_ = value;
}
inline void CMsgSteamDatagramGameserverSessionEstablished::set_legacy_gameserver_steamid(uint64_t value) {
  _internal_set_legacy_gameserver_steamid(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramGameserverSessionEstablished.legacy_gameserver_steamid)
}

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

// CMsgSteamDatagramConnectionStatsClientToRouter

// optional .CMsgSteamDatagramConnectionQuality quality_relay = 1;
inline bool CMsgSteamDatagramConnectionStatsClientToRouter::_internal_has_quality_relay() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.quality_relay_ != nullptr);
  return value;
}
inline bool CMsgSteamDatagramConnectionStatsClientToRouter::has_quality_relay() const {
  return _internal_has_quality_relay();
}
inline const ::CMsgSteamDatagramConnectionQuality& CMsgSteamDatagramConnectionStatsClientToRouter::_internal_quality_relay() const {
  const ::CMsgSteamDatagramConnectionQuality* p = _impl_.quality_relay_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgSteamDatagramConnectionQuality&>(
      ::_CMsgSteamDatagramConnectionQuality_default_instance_);
}
inline const ::CMsgSteamDatagramConnectionQuality& CMsgSteamDatagramConnectionStatsClientToRouter::quality_relay() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectionStatsClientToRouter.quality_relay)
  return _internal_quality_relay();
}
inline void CMsgSteamDatagramConnectionStatsClientToRouter::unsafe_arena_set_allocated_quality_relay(
    ::CMsgSteamDatagramConnectionQuality* quality_relay) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.quality_relay_);
  }
  _impl_.quality_relay_ = quality_relay;
  if (quality_relay) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgSteamDatagramConnectionStatsClientToRouter.quality_relay)
}
inline ::CMsgSteamDatagramConnectionQuality* CMsgSteamDatagramConnectionStatsClientToRouter::release_quality_relay() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgSteamDatagramConnectionQuality* temp = _impl_.quality_relay_;
  _impl_.quality_relay_ = 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 ::CMsgSteamDatagramConnectionQuality* CMsgSteamDatagramConnectionStatsClientToRouter::unsafe_arena_release_quality_relay() {
  // @@protoc_insertion_point(field_release:CMsgSteamDatagramConnectionStatsClientToRouter.quality_relay)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgSteamDatagramConnectionQuality* temp = _impl_.quality_relay_;
  _impl_.quality_relay_ = nullptr;
  return temp;
}
inline ::CMsgSteamDatagramConnectionQuality* CMsgSteamDatagramConnectionStatsClientToRouter::_internal_mutable_quality_relay() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.quality_relay_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgSteamDatagramConnectionQuality>(GetArenaForAllocation());
    _impl_.quality_relay_ = p;
  }
  return _impl_.quality_relay_;
}
inline ::CMsgSteamDatagramConnectionQuality* CMsgSteamDatagramConnectionStatsClientToRouter::mutable_quality_relay() {
  ::CMsgSteamDatagramConnectionQuality* _msg = _internal_mutable_quality_relay();
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramConnectionStatsClientToRouter.quality_relay)
  return _msg;
}
inline void CMsgSteamDatagramConnectionStatsClientToRouter::set_allocated_quality_relay(::CMsgSteamDatagramConnectionQuality* quality_relay) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.quality_relay_);
  }
  if (quality_relay) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(quality_relay));
    if (message_arena != submessage_arena) {
      quality_relay = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, quality_relay, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.quality_relay_ = quality_relay;
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamDatagramConnectionStatsClientToRouter.quality_relay)
}

// optional .CMsgSteamDatagramConnectionQuality quality_e2e = 2;
inline bool CMsgSteamDatagramConnectionStatsClientToRouter::_internal_has_quality_e2e() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.quality_e2e_ != nullptr);
  return value;
}
inline bool CMsgSteamDatagramConnectionStatsClientToRouter::has_quality_e2e() const {
  return _internal_has_quality_e2e();
}
inline const ::CMsgSteamDatagramConnectionQuality& CMsgSteamDatagramConnectionStatsClientToRouter::_internal_quality_e2e() const {
  const ::CMsgSteamDatagramConnectionQuality* p = _impl_.quality_e2e_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgSteamDatagramConnectionQuality&>(
      ::_CMsgSteamDatagramConnectionQuality_default_instance_);
}
inline const ::CMsgSteamDatagramConnectionQuality& CMsgSteamDatagramConnectionStatsClientToRouter::quality_e2e() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectionStatsClientToRouter.quality_e2e)
  return _internal_quality_e2e();
}
inline void CMsgSteamDatagramConnectionStatsClientToRouter::unsafe_arena_set_allocated_quality_e2e(
    ::CMsgSteamDatagramConnectionQuality* quality_e2e) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.quality_e2e_);
  }
  _impl_.quality_e2e_ = quality_e2e;
  if (quality_e2e) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgSteamDatagramConnectionStatsClientToRouter.quality_e2e)
}
inline ::CMsgSteamDatagramConnectionQuality* CMsgSteamDatagramConnectionStatsClientToRouter::release_quality_e2e() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgSteamDatagramConnectionQuality* temp = _impl_.quality_e2e_;
  _impl_.quality_e2e_ = 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 ::CMsgSteamDatagramConnectionQuality* CMsgSteamDatagramConnectionStatsClientToRouter::unsafe_arena_release_quality_e2e() {
  // @@protoc_insertion_point(field_release:CMsgSteamDatagramConnectionStatsClientToRouter.quality_e2e)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgSteamDatagramConnectionQuality* temp = _impl_.quality_e2e_;
  _impl_.quality_e2e_ = nullptr;
  return temp;
}
inline ::CMsgSteamDatagramConnectionQuality* CMsgSteamDatagramConnectionStatsClientToRouter::_internal_mutable_quality_e2e() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.quality_e2e_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgSteamDatagramConnectionQuality>(GetArenaForAllocation());
    _impl_.quality_e2e_ = p;
  }
  return _impl_.quality_e2e_;
}
inline ::CMsgSteamDatagramConnectionQuality* CMsgSteamDatagramConnectionStatsClientToRouter::mutable_quality_e2e() {
  ::CMsgSteamDatagramConnectionQuality* _msg = _internal_mutable_quality_e2e();
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramConnectionStatsClientToRouter.quality_e2e)
  return _msg;
}
inline void CMsgSteamDatagramConnectionStatsClientToRouter::set_allocated_quality_e2e(::CMsgSteamDatagramConnectionQuality* quality_e2e) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.quality_e2e_);
  }
  if (quality_e2e) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(quality_e2e));
    if (message_arena != submessage_arena) {
      quality_e2e = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, quality_e2e, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.quality_e2e_ = quality_e2e;
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamDatagramConnectionStatsClientToRouter.quality_e2e)
}

// repeated fixed32 ack_relay = 4;
inline int CMsgSteamDatagramConnectionStatsClientToRouter::_internal_ack_relay_size() const {
  return _impl_.ack_relay_.size();
}
inline int CMsgSteamDatagramConnectionStatsClientToRouter::ack_relay_size() const {
  return _internal_ack_relay_size();
}
inline void CMsgSteamDatagramConnectionStatsClientToRouter::clear_ack_relay() {
  _impl_.ack_relay_.Clear();
}
inline uint32_t CMsgSteamDatagramConnectionStatsClientToRouter::_internal_ack_relay(int index) const {
  return _impl_.ack_relay_.Get(index);
}
inline uint32_t CMsgSteamDatagramConnectionStatsClientToRouter::ack_relay(int index) const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectionStatsClientToRouter.ack_relay)
  return _internal_ack_relay(index);
}
inline void CMsgSteamDatagramConnectionStatsClientToRouter::set_ack_relay(int index, uint32_t value) {
  _impl_.ack_relay_.Set(index, value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramConnectionStatsClientToRouter.ack_relay)
}
inline void CMsgSteamDatagramConnectionStatsClientToRouter::_internal_add_ack_relay(uint32_t value) {
  _impl_.ack_relay_.Add(value);
}
inline void CMsgSteamDatagramConnectionStatsClientToRouter::add_ack_relay(uint32_t value) {
  _internal_add_ack_relay(value);
  // @@protoc_insertion_point(field_add:CMsgSteamDatagramConnectionStatsClientToRouter.ack_relay)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
CMsgSteamDatagramConnectionStatsClientToRouter::_internal_ack_relay() const {
  return _impl_.ack_relay_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
CMsgSteamDatagramConnectionStatsClientToRouter::ack_relay() const {
  // @@protoc_insertion_point(field_list:CMsgSteamDatagramConnectionStatsClientToRouter.ack_relay)
  return _internal_ack_relay();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
CMsgSteamDatagramConnectionStatsClientToRouter::_internal_mutable_ack_relay() {
  return &_impl_.ack_relay_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
CMsgSteamDatagramConnectionStatsClientToRouter::mutable_ack_relay() {
  // @@protoc_insertion_point(field_mutable_list:CMsgSteamDatagramConnectionStatsClientToRouter.ack_relay)
  return _internal_mutable_ack_relay();
}

// repeated fixed32 legacy_ack_e2e = 5;
inline int CMsgSteamDatagramConnectionStatsClientToRouter::_internal_legacy_ack_e2e_size() const {
  return _impl_.legacy_ack_e2e_.size();
}
inline int CMsgSteamDatagramConnectionStatsClientToRouter::legacy_ack_e2e_size() const {
  return _internal_legacy_ack_e2e_size();
}
inline void CMsgSteamDatagramConnectionStatsClientToRouter::clear_legacy_ack_e2e() {
  _impl_.legacy_ack_e2e_.Clear();
}
inline uint32_t CMsgSteamDatagramConnectionStatsClientToRouter::_internal_legacy_ack_e2e(int index) const {
  return _impl_.legacy_ack_e2e_.Get(index);
}
inline uint32_t CMsgSteamDatagramConnectionStatsClientToRouter::legacy_ack_e2e(int index) const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectionStatsClientToRouter.legacy_ack_e2e)
  return _internal_legacy_ack_e2e(index);
}
inline void CMsgSteamDatagramConnectionStatsClientToRouter::set_legacy_ack_e2e(int index, uint32_t value) {
  _impl_.legacy_ack_e2e_.Set(index, value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramConnectionStatsClientToRouter.legacy_ack_e2e)
}
inline void CMsgSteamDatagramConnectionStatsClientToRouter::_internal_add_legacy_ack_e2e(uint32_t value) {
  _impl_.legacy_ack_e2e_.Add(value);
}
inline void CMsgSteamDatagramConnectionStatsClientToRouter::add_legacy_ack_e2e(uint32_t value) {
  _internal_add_legacy_ack_e2e(value);
  // @@protoc_insertion_point(field_add:CMsgSteamDatagramConnectionStatsClientToRouter.legacy_ack_e2e)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
CMsgSteamDatagramConnectionStatsClientToRouter::_internal_legacy_ack_e2e() const {
  return _impl_.legacy_ack_e2e_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
CMsgSteamDatagramConnectionStatsClientToRouter::legacy_ack_e2e() const {
  // @@protoc_insertion_point(field_list:CMsgSteamDatagramConnectionStatsClientToRouter.legacy_ack_e2e)
  return _internal_legacy_ack_e2e();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
CMsgSteamDatagramConnectionStatsClientToRouter::_internal_mutable_legacy_ack_e2e() {
  return &_impl_.legacy_ack_e2e_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
CMsgSteamDatagramConnectionStatsClientToRouter::mutable_legacy_ack_e2e() {
  // @@protoc_insertion_point(field_mutable_list:CMsgSteamDatagramConnectionStatsClientToRouter.legacy_ack_e2e)
  return _internal_mutable_legacy_ack_e2e();
}

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

// optional fixed32 client_connection_id = 8;
inline bool CMsgSteamDatagramConnectionStatsClientToRouter::_internal_has_client_connection_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CMsgSteamDatagramConnectionStatsClientToRouter::has_client_connection_id() const {
  return _internal_has_client_connection_id();
}
inline void CMsgSteamDatagramConnectionStatsClientToRouter::clear_client_connection_id() {
  _impl_.client_connection_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t CMsgSteamDatagramConnectionStatsClientToRouter::_internal_client_connection_id() const {
  return _impl_.client_connection_id_;
}
inline uint32_t CMsgSteamDatagramConnectionStatsClientToRouter::client_connection_id() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectionStatsClientToRouter.client_connection_id)
  return _internal_client_connection_id();
}
inline void CMsgSteamDatagramConnectionStatsClientToRouter::_internal_set_client_connection_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.client_connection_id_ = value;
}
inline void CMsgSteamDatagramConnectionStatsClientToRouter::set_client_connection_id(uint32_t value) {
  _internal_set_client_connection_id(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramConnectionStatsClientToRouter.client_connection_id)
}

// optional uint32 seq_num_c2r = 9;
inline bool CMsgSteamDatagramConnectionStatsClientToRouter::_internal_has_seq_num_c2r() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CMsgSteamDatagramConnectionStatsClientToRouter::has_seq_num_c2r() const {
  return _internal_has_seq_num_c2r();
}
inline void CMsgSteamDatagramConnectionStatsClientToRouter::clear_seq_num_c2r() {
  _impl_.seq_num_c2r_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline uint32_t CMsgSteamDatagramConnectionStatsClientToRouter::_internal_seq_num_c2r() const {
  return _impl_.seq_num_c2r_;
}
inline uint32_t CMsgSteamDatagramConnectionStatsClientToRouter::seq_num_c2r() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectionStatsClientToRouter.seq_num_c2r)
  return _internal_seq_num_c2r();
}
inline void CMsgSteamDatagramConnectionStatsClientToRouter::_internal_set_seq_num_c2r(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.seq_num_c2r_ = value;
}
inline void CMsgSteamDatagramConnectionStatsClientToRouter::set_seq_num_c2r(uint32_t value) {
  _internal_set_seq_num_c2r(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramConnectionStatsClientToRouter.seq_num_c2r)
}

// optional uint32 seq_num_e2e = 10;
inline bool CMsgSteamDatagramConnectionStatsClientToRouter::_internal_has_seq_num_e2e() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool CMsgSteamDatagramConnectionStatsClientToRouter::has_seq_num_e2e() const {
  return _internal_has_seq_num_e2e();
}
inline void CMsgSteamDatagramConnectionStatsClientToRouter::clear_seq_num_e2e() {
  _impl_.seq_num_e2e_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline uint32_t CMsgSteamDatagramConnectionStatsClientToRouter::_internal_seq_num_e2e() const {
  return _impl_.seq_num_e2e_;
}
inline uint32_t CMsgSteamDatagramConnectionStatsClientToRouter::seq_num_e2e() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectionStatsClientToRouter.seq_num_e2e)
  return _internal_seq_num_e2e();
}
inline void CMsgSteamDatagramConnectionStatsClientToRouter::_internal_set_seq_num_e2e(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.seq_num_e2e_ = value;
}
inline void CMsgSteamDatagramConnectionStatsClientToRouter::set_seq_num_e2e(uint32_t value) {
  _internal_set_seq_num_e2e(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramConnectionStatsClientToRouter.seq_num_e2e)
}

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

// CMsgSteamDatagramConnectionStatsRouterToClient

// optional .CMsgSteamDatagramConnectionQuality quality_relay = 1;
inline bool CMsgSteamDatagramConnectionStatsRouterToClient::_internal_has_quality_relay() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.quality_relay_ != nullptr);
  return value;
}
inline bool CMsgSteamDatagramConnectionStatsRouterToClient::has_quality_relay() const {
  return _internal_has_quality_relay();
}
inline const ::CMsgSteamDatagramConnectionQuality& CMsgSteamDatagramConnectionStatsRouterToClient::_internal_quality_relay() const {
  const ::CMsgSteamDatagramConnectionQuality* p = _impl_.quality_relay_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgSteamDatagramConnectionQuality&>(
      ::_CMsgSteamDatagramConnectionQuality_default_instance_);
}
inline const ::CMsgSteamDatagramConnectionQuality& CMsgSteamDatagramConnectionStatsRouterToClient::quality_relay() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectionStatsRouterToClient.quality_relay)
  return _internal_quality_relay();
}
inline void CMsgSteamDatagramConnectionStatsRouterToClient::unsafe_arena_set_allocated_quality_relay(
    ::CMsgSteamDatagramConnectionQuality* quality_relay) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.quality_relay_);
  }
  _impl_.quality_relay_ = quality_relay;
  if (quality_relay) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgSteamDatagramConnectionStatsRouterToClient.quality_relay)
}
inline ::CMsgSteamDatagramConnectionQuality* CMsgSteamDatagramConnectionStatsRouterToClient::release_quality_relay() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgSteamDatagramConnectionQuality* temp = _impl_.quality_relay_;
  _impl_.quality_relay_ = 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 ::CMsgSteamDatagramConnectionQuality* CMsgSteamDatagramConnectionStatsRouterToClient::unsafe_arena_release_quality_relay() {
  // @@protoc_insertion_point(field_release:CMsgSteamDatagramConnectionStatsRouterToClient.quality_relay)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgSteamDatagramConnectionQuality* temp = _impl_.quality_relay_;
  _impl_.quality_relay_ = nullptr;
  return temp;
}
inline ::CMsgSteamDatagramConnectionQuality* CMsgSteamDatagramConnectionStatsRouterToClient::_internal_mutable_quality_relay() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.quality_relay_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgSteamDatagramConnectionQuality>(GetArenaForAllocation());
    _impl_.quality_relay_ = p;
  }
  return _impl_.quality_relay_;
}
inline ::CMsgSteamDatagramConnectionQuality* CMsgSteamDatagramConnectionStatsRouterToClient::mutable_quality_relay() {
  ::CMsgSteamDatagramConnectionQuality* _msg = _internal_mutable_quality_relay();
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramConnectionStatsRouterToClient.quality_relay)
  return _msg;
}
inline void CMsgSteamDatagramConnectionStatsRouterToClient::set_allocated_quality_relay(::CMsgSteamDatagramConnectionQuality* quality_relay) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.quality_relay_);
  }
  if (quality_relay) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(quality_relay));
    if (message_arena != submessage_arena) {
      quality_relay = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, quality_relay, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.quality_relay_ = quality_relay;
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamDatagramConnectionStatsRouterToClient.quality_relay)
}

// optional .CMsgSteamDatagramConnectionQuality quality_e2e = 2;
inline bool CMsgSteamDatagramConnectionStatsRouterToClient::_internal_has_quality_e2e() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.quality_e2e_ != nullptr);
  return value;
}
inline bool CMsgSteamDatagramConnectionStatsRouterToClient::has_quality_e2e() const {
  return _internal_has_quality_e2e();
}
inline const ::CMsgSteamDatagramConnectionQuality& CMsgSteamDatagramConnectionStatsRouterToClient::_internal_quality_e2e() const {
  const ::CMsgSteamDatagramConnectionQuality* p = _impl_.quality_e2e_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgSteamDatagramConnectionQuality&>(
      ::_CMsgSteamDatagramConnectionQuality_default_instance_);
}
inline const ::CMsgSteamDatagramConnectionQuality& CMsgSteamDatagramConnectionStatsRouterToClient::quality_e2e() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectionStatsRouterToClient.quality_e2e)
  return _internal_quality_e2e();
}
inline void CMsgSteamDatagramConnectionStatsRouterToClient::unsafe_arena_set_allocated_quality_e2e(
    ::CMsgSteamDatagramConnectionQuality* quality_e2e) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.quality_e2e_);
  }
  _impl_.quality_e2e_ = quality_e2e;
  if (quality_e2e) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgSteamDatagramConnectionStatsRouterToClient.quality_e2e)
}
inline ::CMsgSteamDatagramConnectionQuality* CMsgSteamDatagramConnectionStatsRouterToClient::release_quality_e2e() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgSteamDatagramConnectionQuality* temp = _impl_.quality_e2e_;
  _impl_.quality_e2e_ = 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 ::CMsgSteamDatagramConnectionQuality* CMsgSteamDatagramConnectionStatsRouterToClient::unsafe_arena_release_quality_e2e() {
  // @@protoc_insertion_point(field_release:CMsgSteamDatagramConnectionStatsRouterToClient.quality_e2e)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgSteamDatagramConnectionQuality* temp = _impl_.quality_e2e_;
  _impl_.quality_e2e_ = nullptr;
  return temp;
}
inline ::CMsgSteamDatagramConnectionQuality* CMsgSteamDatagramConnectionStatsRouterToClient::_internal_mutable_quality_e2e() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.quality_e2e_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgSteamDatagramConnectionQuality>(GetArenaForAllocation());
    _impl_.quality_e2e_ = p;
  }
  return _impl_.quality_e2e_;
}
inline ::CMsgSteamDatagramConnectionQuality* CMsgSteamDatagramConnectionStatsRouterToClient::mutable_quality_e2e() {
  ::CMsgSteamDatagramConnectionQuality* _msg = _internal_mutable_quality_e2e();
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramConnectionStatsRouterToClient.quality_e2e)
  return _msg;
}
inline void CMsgSteamDatagramConnectionStatsRouterToClient::set_allocated_quality_e2e(::CMsgSteamDatagramConnectionQuality* quality_e2e) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.quality_e2e_);
  }
  if (quality_e2e) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(quality_e2e));
    if (message_arena != submessage_arena) {
      quality_e2e = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, quality_e2e, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.quality_e2e_ = quality_e2e;
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamDatagramConnectionStatsRouterToClient.quality_e2e)
}

// optional uint32 seconds_until_shutdown = 6;
inline bool CMsgSteamDatagramConnectionStatsRouterToClient::_internal_has_seconds_until_shutdown() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgSteamDatagramConnectionStatsRouterToClient::has_seconds_until_shutdown() const {
  return _internal_has_seconds_until_shutdown();
}
inline void CMsgSteamDatagramConnectionStatsRouterToClient::clear_seconds_until_shutdown() {
  _impl_.seconds_until_shutdown_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t CMsgSteamDatagramConnectionStatsRouterToClient::_internal_seconds_until_shutdown() const {
  return _impl_.seconds_until_shutdown_;
}
inline uint32_t CMsgSteamDatagramConnectionStatsRouterToClient::seconds_until_shutdown() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectionStatsRouterToClient.seconds_until_shutdown)
  return _internal_seconds_until_shutdown();
}
inline void CMsgSteamDatagramConnectionStatsRouterToClient::_internal_set_seconds_until_shutdown(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.seconds_until_shutdown_ = value;
}
inline void CMsgSteamDatagramConnectionStatsRouterToClient::set_seconds_until_shutdown(uint32_t value) {
  _internal_set_seconds_until_shutdown(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramConnectionStatsRouterToClient.seconds_until_shutdown)
}

// optional fixed32 migrate_request_ip = 10;
inline bool CMsgSteamDatagramConnectionStatsRouterToClient::_internal_has_migrate_request_ip() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool CMsgSteamDatagramConnectionStatsRouterToClient::has_migrate_request_ip() const {
  return _internal_has_migrate_request_ip();
}
inline void CMsgSteamDatagramConnectionStatsRouterToClient::clear_migrate_request_ip() {
  _impl_.migrate_request_ip_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline uint32_t CMsgSteamDatagramConnectionStatsRouterToClient::_internal_migrate_request_ip() const {
  return _impl_.migrate_request_ip_;
}
inline uint32_t CMsgSteamDatagramConnectionStatsRouterToClient::migrate_request_ip() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectionStatsRouterToClient.migrate_request_ip)
  return _internal_migrate_request_ip();
}
inline void CMsgSteamDatagramConnectionStatsRouterToClient::_internal_set_migrate_request_ip(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.migrate_request_ip_ = value;
}
inline void CMsgSteamDatagramConnectionStatsRouterToClient::set_migrate_request_ip(uint32_t value) {
  _internal_set_migrate_request_ip(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramConnectionStatsRouterToClient.migrate_request_ip)
}

// optional uint32 migrate_request_port = 11;
inline bool CMsgSteamDatagramConnectionStatsRouterToClient::_internal_has_migrate_request_port() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool CMsgSteamDatagramConnectionStatsRouterToClient::has_migrate_request_port() const {
  return _internal_has_migrate_request_port();
}
inline void CMsgSteamDatagramConnectionStatsRouterToClient::clear_migrate_request_port() {
  _impl_.migrate_request_port_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline uint32_t CMsgSteamDatagramConnectionStatsRouterToClient::_internal_migrate_request_port() const {
  return _impl_.migrate_request_port_;
}
inline uint32_t CMsgSteamDatagramConnectionStatsRouterToClient::migrate_request_port() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectionStatsRouterToClient.migrate_request_port)
  return _internal_migrate_request_port();
}
inline void CMsgSteamDatagramConnectionStatsRouterToClient::_internal_set_migrate_request_port(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.migrate_request_port_ = value;
}
inline void CMsgSteamDatagramConnectionStatsRouterToClient::set_migrate_request_port(uint32_t value) {
  _internal_set_migrate_request_port(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramConnectionStatsRouterToClient.migrate_request_port)
}

// optional uint32 scoring_penalty_relay_cluster = 12;
inline bool CMsgSteamDatagramConnectionStatsRouterToClient::_internal_has_scoring_penalty_relay_cluster() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool CMsgSteamDatagramConnectionStatsRouterToClient::has_scoring_penalty_relay_cluster() const {
  return _internal_has_scoring_penalty_relay_cluster();
}
inline void CMsgSteamDatagramConnectionStatsRouterToClient::clear_scoring_penalty_relay_cluster() {
  _impl_.scoring_penalty_relay_cluster_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline uint32_t CMsgSteamDatagramConnectionStatsRouterToClient::_internal_scoring_penalty_relay_cluster() const {
  return _impl_.scoring_penalty_relay_cluster_;
}
inline uint32_t CMsgSteamDatagramConnectionStatsRouterToClient::scoring_penalty_relay_cluster() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectionStatsRouterToClient.scoring_penalty_relay_cluster)
  return _internal_scoring_penalty_relay_cluster();
}
inline void CMsgSteamDatagramConnectionStatsRouterToClient::_internal_set_scoring_penalty_relay_cluster(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.scoring_penalty_relay_cluster_ = value;
}
inline void CMsgSteamDatagramConnectionStatsRouterToClient::set_scoring_penalty_relay_cluster(uint32_t value) {
  _internal_set_scoring_penalty_relay_cluster(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramConnectionStatsRouterToClient.scoring_penalty_relay_cluster)
}

// repeated fixed32 ack_relay = 13;
inline int CMsgSteamDatagramConnectionStatsRouterToClient::_internal_ack_relay_size() const {
  return _impl_.ack_relay_.size();
}
inline int CMsgSteamDatagramConnectionStatsRouterToClient::ack_relay_size() const {
  return _internal_ack_relay_size();
}
inline void CMsgSteamDatagramConnectionStatsRouterToClient::clear_ack_relay() {
  _impl_.ack_relay_.Clear();
}
inline uint32_t CMsgSteamDatagramConnectionStatsRouterToClient::_internal_ack_relay(int index) const {
  return _impl_.ack_relay_.Get(index);
}
inline uint32_t CMsgSteamDatagramConnectionStatsRouterToClient::ack_relay(int index) const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectionStatsRouterToClient.ack_relay)
  return _internal_ack_relay(index);
}
inline void CMsgSteamDatagramConnectionStatsRouterToClient::set_ack_relay(int index, uint32_t value) {
  _impl_.ack_relay_.Set(index, value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramConnectionStatsRouterToClient.ack_relay)
}
inline void CMsgSteamDatagramConnectionStatsRouterToClient::_internal_add_ack_relay(uint32_t value) {
  _impl_.ack_relay_.Add(value);
}
inline void CMsgSteamDatagramConnectionStatsRouterToClient::add_ack_relay(uint32_t value) {
  _internal_add_ack_relay(value);
  // @@protoc_insertion_point(field_add:CMsgSteamDatagramConnectionStatsRouterToClient.ack_relay)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
CMsgSteamDatagramConnectionStatsRouterToClient::_internal_ack_relay() const {
  return _impl_.ack_relay_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
CMsgSteamDatagramConnectionStatsRouterToClient::ack_relay() const {
  // @@protoc_insertion_point(field_list:CMsgSteamDatagramConnectionStatsRouterToClient.ack_relay)
  return _internal_ack_relay();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
CMsgSteamDatagramConnectionStatsRouterToClient::_internal_mutable_ack_relay() {
  return &_impl_.ack_relay_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
CMsgSteamDatagramConnectionStatsRouterToClient::mutable_ack_relay() {
  // @@protoc_insertion_point(field_mutable_list:CMsgSteamDatagramConnectionStatsRouterToClient.ack_relay)
  return _internal_mutable_ack_relay();
}

// repeated fixed32 legacy_ack_e2e = 14;
inline int CMsgSteamDatagramConnectionStatsRouterToClient::_internal_legacy_ack_e2e_size() const {
  return _impl_.legacy_ack_e2e_.size();
}
inline int CMsgSteamDatagramConnectionStatsRouterToClient::legacy_ack_e2e_size() const {
  return _internal_legacy_ack_e2e_size();
}
inline void CMsgSteamDatagramConnectionStatsRouterToClient::clear_legacy_ack_e2e() {
  _impl_.legacy_ack_e2e_.Clear();
}
inline uint32_t CMsgSteamDatagramConnectionStatsRouterToClient::_internal_legacy_ack_e2e(int index) const {
  return _impl_.legacy_ack_e2e_.Get(index);
}
inline uint32_t CMsgSteamDatagramConnectionStatsRouterToClient::legacy_ack_e2e(int index) const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectionStatsRouterToClient.legacy_ack_e2e)
  return _internal_legacy_ack_e2e(index);
}
inline void CMsgSteamDatagramConnectionStatsRouterToClient::set_legacy_ack_e2e(int index, uint32_t value) {
  _impl_.legacy_ack_e2e_.Set(index, value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramConnectionStatsRouterToClient.legacy_ack_e2e)
}
inline void CMsgSteamDatagramConnectionStatsRouterToClient::_internal_add_legacy_ack_e2e(uint32_t value) {
  _impl_.legacy_ack_e2e_.Add(value);
}
inline void CMsgSteamDatagramConnectionStatsRouterToClient::add_legacy_ack_e2e(uint32_t value) {
  _internal_add_legacy_ack_e2e(value);
  // @@protoc_insertion_point(field_add:CMsgSteamDatagramConnectionStatsRouterToClient.legacy_ack_e2e)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
CMsgSteamDatagramConnectionStatsRouterToClient::_internal_legacy_ack_e2e() const {
  return _impl_.legacy_ack_e2e_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
CMsgSteamDatagramConnectionStatsRouterToClient::legacy_ack_e2e() const {
  // @@protoc_insertion_point(field_list:CMsgSteamDatagramConnectionStatsRouterToClient.legacy_ack_e2e)
  return _internal_legacy_ack_e2e();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
CMsgSteamDatagramConnectionStatsRouterToClient::_internal_mutable_legacy_ack_e2e() {
  return &_impl_.legacy_ack_e2e_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
CMsgSteamDatagramConnectionStatsRouterToClient::mutable_legacy_ack_e2e() {
  // @@protoc_insertion_point(field_mutable_list:CMsgSteamDatagramConnectionStatsRouterToClient.legacy_ack_e2e)
  return _internal_mutable_legacy_ack_e2e();
}

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

// optional fixed32 client_connection_id = 7;
inline bool CMsgSteamDatagramConnectionStatsRouterToClient::_internal_has_client_connection_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CMsgSteamDatagramConnectionStatsRouterToClient::has_client_connection_id() const {
  return _internal_has_client_connection_id();
}
inline void CMsgSteamDatagramConnectionStatsRouterToClient::clear_client_connection_id() {
  _impl_.client_connection_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t CMsgSteamDatagramConnectionStatsRouterToClient::_internal_client_connection_id() const {
  return _impl_.client_connection_id_;
}
inline uint32_t CMsgSteamDatagramConnectionStatsRouterToClient::client_connection_id() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectionStatsRouterToClient.client_connection_id)
  return _internal_client_connection_id();
}
inline void CMsgSteamDatagramConnectionStatsRouterToClient::_internal_set_client_connection_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.client_connection_id_ = value;
}
inline void CMsgSteamDatagramConnectionStatsRouterToClient::set_client_connection_id(uint32_t value) {
  _internal_set_client_connection_id(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramConnectionStatsRouterToClient.client_connection_id)
}

// optional uint32 seq_num_r2c = 8;
inline bool CMsgSteamDatagramConnectionStatsRouterToClient::_internal_has_seq_num_r2c() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CMsgSteamDatagramConnectionStatsRouterToClient::has_seq_num_r2c() const {
  return _internal_has_seq_num_r2c();
}
inline void CMsgSteamDatagramConnectionStatsRouterToClient::clear_seq_num_r2c() {
  _impl_.seq_num_r2c_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline uint32_t CMsgSteamDatagramConnectionStatsRouterToClient::_internal_seq_num_r2c() const {
  return _impl_.seq_num_r2c_;
}
inline uint32_t CMsgSteamDatagramConnectionStatsRouterToClient::seq_num_r2c() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectionStatsRouterToClient.seq_num_r2c)
  return _internal_seq_num_r2c();
}
inline void CMsgSteamDatagramConnectionStatsRouterToClient::_internal_set_seq_num_r2c(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.seq_num_r2c_ = value;
}
inline void CMsgSteamDatagramConnectionStatsRouterToClient::set_seq_num_r2c(uint32_t value) {
  _internal_set_seq_num_r2c(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramConnectionStatsRouterToClient.seq_num_r2c)
}

// optional uint32 seq_num_e2e = 9;
inline bool CMsgSteamDatagramConnectionStatsRouterToClient::_internal_has_seq_num_e2e() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool CMsgSteamDatagramConnectionStatsRouterToClient::has_seq_num_e2e() const {
  return _internal_has_seq_num_e2e();
}
inline void CMsgSteamDatagramConnectionStatsRouterToClient::clear_seq_num_e2e() {
  _impl_.seq_num_e2e_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline uint32_t CMsgSteamDatagramConnectionStatsRouterToClient::_internal_seq_num_e2e() const {
  return _impl_.seq_num_e2e_;
}
inline uint32_t CMsgSteamDatagramConnectionStatsRouterToClient::seq_num_e2e() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectionStatsRouterToClient.seq_num_e2e)
  return _internal_seq_num_e2e();
}
inline void CMsgSteamDatagramConnectionStatsRouterToClient::_internal_set_seq_num_e2e(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.seq_num_e2e_ = value;
}
inline void CMsgSteamDatagramConnectionStatsRouterToClient::set_seq_num_e2e(uint32_t value) {
  _internal_set_seq_num_e2e(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramConnectionStatsRouterToClient.seq_num_e2e)
}

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

// CMsgSteamDatagramConnectionStatsRouterToServer

// optional .CMsgSteamDatagramConnectionQuality quality_relay = 1;
inline bool CMsgSteamDatagramConnectionStatsRouterToServer::_internal_has_quality_relay() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.quality_relay_ != nullptr);
  return value;
}
inline bool CMsgSteamDatagramConnectionStatsRouterToServer::has_quality_relay() const {
  return _internal_has_quality_relay();
}
inline const ::CMsgSteamDatagramConnectionQuality& CMsgSteamDatagramConnectionStatsRouterToServer::_internal_quality_relay() const {
  const ::CMsgSteamDatagramConnectionQuality* p = _impl_.quality_relay_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgSteamDatagramConnectionQuality&>(
      ::_CMsgSteamDatagramConnectionQuality_default_instance_);
}
inline const ::CMsgSteamDatagramConnectionQuality& CMsgSteamDatagramConnectionStatsRouterToServer::quality_relay() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectionStatsRouterToServer.quality_relay)
  return _internal_quality_relay();
}
inline void CMsgSteamDatagramConnectionStatsRouterToServer::unsafe_arena_set_allocated_quality_relay(
    ::CMsgSteamDatagramConnectionQuality* quality_relay) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.quality_relay_);
  }
  _impl_.quality_relay_ = quality_relay;
  if (quality_relay) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgSteamDatagramConnectionStatsRouterToServer.quality_relay)
}
inline ::CMsgSteamDatagramConnectionQuality* CMsgSteamDatagramConnectionStatsRouterToServer::release_quality_relay() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgSteamDatagramConnectionQuality* temp = _impl_.quality_relay_;
  _impl_.quality_relay_ = 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 ::CMsgSteamDatagramConnectionQuality* CMsgSteamDatagramConnectionStatsRouterToServer::unsafe_arena_release_quality_relay() {
  // @@protoc_insertion_point(field_release:CMsgSteamDatagramConnectionStatsRouterToServer.quality_relay)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgSteamDatagramConnectionQuality* temp = _impl_.quality_relay_;
  _impl_.quality_relay_ = nullptr;
  return temp;
}
inline ::CMsgSteamDatagramConnectionQuality* CMsgSteamDatagramConnectionStatsRouterToServer::_internal_mutable_quality_relay() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.quality_relay_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgSteamDatagramConnectionQuality>(GetArenaForAllocation());
    _impl_.quality_relay_ = p;
  }
  return _impl_.quality_relay_;
}
inline ::CMsgSteamDatagramConnectionQuality* CMsgSteamDatagramConnectionStatsRouterToServer::mutable_quality_relay() {
  ::CMsgSteamDatagramConnectionQuality* _msg = _internal_mutable_quality_relay();
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramConnectionStatsRouterToServer.quality_relay)
  return _msg;
}
inline void CMsgSteamDatagramConnectionStatsRouterToServer::set_allocated_quality_relay(::CMsgSteamDatagramConnectionQuality* quality_relay) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.quality_relay_);
  }
  if (quality_relay) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(quality_relay));
    if (message_arena != submessage_arena) {
      quality_relay = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, quality_relay, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.quality_relay_ = quality_relay;
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamDatagramConnectionStatsRouterToServer.quality_relay)
}

// optional .CMsgSteamDatagramConnectionQuality quality_e2e = 2;
inline bool CMsgSteamDatagramConnectionStatsRouterToServer::_internal_has_quality_e2e() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.quality_e2e_ != nullptr);
  return value;
}
inline bool CMsgSteamDatagramConnectionStatsRouterToServer::has_quality_e2e() const {
  return _internal_has_quality_e2e();
}
inline const ::CMsgSteamDatagramConnectionQuality& CMsgSteamDatagramConnectionStatsRouterToServer::_internal_quality_e2e() const {
  const ::CMsgSteamDatagramConnectionQuality* p = _impl_.quality_e2e_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgSteamDatagramConnectionQuality&>(
      ::_CMsgSteamDatagramConnectionQuality_default_instance_);
}
inline const ::CMsgSteamDatagramConnectionQuality& CMsgSteamDatagramConnectionStatsRouterToServer::quality_e2e() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectionStatsRouterToServer.quality_e2e)
  return _internal_quality_e2e();
}
inline void CMsgSteamDatagramConnectionStatsRouterToServer::unsafe_arena_set_allocated_quality_e2e(
    ::CMsgSteamDatagramConnectionQuality* quality_e2e) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.quality_e2e_);
  }
  _impl_.quality_e2e_ = quality_e2e;
  if (quality_e2e) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgSteamDatagramConnectionStatsRouterToServer.quality_e2e)
}
inline ::CMsgSteamDatagramConnectionQuality* CMsgSteamDatagramConnectionStatsRouterToServer::release_quality_e2e() {
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::CMsgSteamDatagramConnectionQuality* temp = _impl_.quality_e2e_;
  _impl_.quality_e2e_ = 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 ::CMsgSteamDatagramConnectionQuality* CMsgSteamDatagramConnectionStatsRouterToServer::unsafe_arena_release_quality_e2e() {
  // @@protoc_insertion_point(field_release:CMsgSteamDatagramConnectionStatsRouterToServer.quality_e2e)
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::CMsgSteamDatagramConnectionQuality* temp = _impl_.quality_e2e_;
  _impl_.quality_e2e_ = nullptr;
  return temp;
}
inline ::CMsgSteamDatagramConnectionQuality* CMsgSteamDatagramConnectionStatsRouterToServer::_internal_mutable_quality_e2e() {
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.quality_e2e_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgSteamDatagramConnectionQuality>(GetArenaForAllocation());
    _impl_.quality_e2e_ = p;
  }
  return _impl_.quality_e2e_;
}
inline ::CMsgSteamDatagramConnectionQuality* CMsgSteamDatagramConnectionStatsRouterToServer::mutable_quality_e2e() {
  ::CMsgSteamDatagramConnectionQuality* _msg = _internal_mutable_quality_e2e();
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramConnectionStatsRouterToServer.quality_e2e)
  return _msg;
}
inline void CMsgSteamDatagramConnectionStatsRouterToServer::set_allocated_quality_e2e(::CMsgSteamDatagramConnectionQuality* quality_e2e) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.quality_e2e_);
  }
  if (quality_e2e) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(quality_e2e));
    if (message_arena != submessage_arena) {
      quality_e2e = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, quality_e2e, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.quality_e2e_ = quality_e2e;
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamDatagramConnectionStatsRouterToServer.quality_e2e)
}

// repeated fixed32 ack_relay = 10;
inline int CMsgSteamDatagramConnectionStatsRouterToServer::_internal_ack_relay_size() const {
  return _impl_.ack_relay_.size();
}
inline int CMsgSteamDatagramConnectionStatsRouterToServer::ack_relay_size() const {
  return _internal_ack_relay_size();
}
inline void CMsgSteamDatagramConnectionStatsRouterToServer::clear_ack_relay() {
  _impl_.ack_relay_.Clear();
}
inline uint32_t CMsgSteamDatagramConnectionStatsRouterToServer::_internal_ack_relay(int index) const {
  return _impl_.ack_relay_.Get(index);
}
inline uint32_t CMsgSteamDatagramConnectionStatsRouterToServer::ack_relay(int index) const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectionStatsRouterToServer.ack_relay)
  return _internal_ack_relay(index);
}
inline void CMsgSteamDatagramConnectionStatsRouterToServer::set_ack_relay(int index, uint32_t value) {
  _impl_.ack_relay_.Set(index, value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramConnectionStatsRouterToServer.ack_relay)
}
inline void CMsgSteamDatagramConnectionStatsRouterToServer::_internal_add_ack_relay(uint32_t value) {
  _impl_.ack_relay_.Add(value);
}
inline void CMsgSteamDatagramConnectionStatsRouterToServer::add_ack_relay(uint32_t value) {
  _internal_add_ack_relay(value);
  // @@protoc_insertion_point(field_add:CMsgSteamDatagramConnectionStatsRouterToServer.ack_relay)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
CMsgSteamDatagramConnectionStatsRouterToServer::_internal_ack_relay() const {
  return _impl_.ack_relay_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
CMsgSteamDatagramConnectionStatsRouterToServer::ack_relay() const {
  // @@protoc_insertion_point(field_list:CMsgSteamDatagramConnectionStatsRouterToServer.ack_relay)
  return _internal_ack_relay();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
CMsgSteamDatagramConnectionStatsRouterToServer::_internal_mutable_ack_relay() {
  return &_impl_.ack_relay_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
CMsgSteamDatagramConnectionStatsRouterToServer::mutable_ack_relay() {
  // @@protoc_insertion_point(field_mutable_list:CMsgSteamDatagramConnectionStatsRouterToServer.ack_relay)
  return _internal_mutable_ack_relay();
}

// repeated fixed32 legacy_ack_e2e = 11;
inline int CMsgSteamDatagramConnectionStatsRouterToServer::_internal_legacy_ack_e2e_size() const {
  return _impl_.legacy_ack_e2e_.size();
}
inline int CMsgSteamDatagramConnectionStatsRouterToServer::legacy_ack_e2e_size() const {
  return _internal_legacy_ack_e2e_size();
}
inline void CMsgSteamDatagramConnectionStatsRouterToServer::clear_legacy_ack_e2e() {
  _impl_.legacy_ack_e2e_.Clear();
}
inline uint32_t CMsgSteamDatagramConnectionStatsRouterToServer::_internal_legacy_ack_e2e(int index) const {
  return _impl_.legacy_ack_e2e_.Get(index);
}
inline uint32_t CMsgSteamDatagramConnectionStatsRouterToServer::legacy_ack_e2e(int index) const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectionStatsRouterToServer.legacy_ack_e2e)
  return _internal_legacy_ack_e2e(index);
}
inline void CMsgSteamDatagramConnectionStatsRouterToServer::set_legacy_ack_e2e(int index, uint32_t value) {
  _impl_.legacy_ack_e2e_.Set(index, value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramConnectionStatsRouterToServer.legacy_ack_e2e)
}
inline void CMsgSteamDatagramConnectionStatsRouterToServer::_internal_add_legacy_ack_e2e(uint32_t value) {
  _impl_.legacy_ack_e2e_.Add(value);
}
inline void CMsgSteamDatagramConnectionStatsRouterToServer::add_legacy_ack_e2e(uint32_t value) {
  _internal_add_legacy_ack_e2e(value);
  // @@protoc_insertion_point(field_add:CMsgSteamDatagramConnectionStatsRouterToServer.legacy_ack_e2e)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
CMsgSteamDatagramConnectionStatsRouterToServer::_internal_legacy_ack_e2e() const {
  return _impl_.legacy_ack_e2e_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
CMsgSteamDatagramConnectionStatsRouterToServer::legacy_ack_e2e() const {
  // @@protoc_insertion_point(field_list:CMsgSteamDatagramConnectionStatsRouterToServer.legacy_ack_e2e)
  return _internal_legacy_ack_e2e();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
CMsgSteamDatagramConnectionStatsRouterToServer::_internal_mutable_legacy_ack_e2e() {
  return &_impl_.legacy_ack_e2e_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
CMsgSteamDatagramConnectionStatsRouterToServer::mutable_legacy_ack_e2e() {
  // @@protoc_insertion_point(field_mutable_list:CMsgSteamDatagramConnectionStatsRouterToServer.legacy_ack_e2e)
  return _internal_mutable_legacy_ack_e2e();
}

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

// optional uint32 seq_num_r2s = 5;
inline bool CMsgSteamDatagramConnectionStatsRouterToServer::_internal_has_seq_num_r2s() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CMsgSteamDatagramConnectionStatsRouterToServer::has_seq_num_r2s() const {
  return _internal_has_seq_num_r2s();
}
inline void CMsgSteamDatagramConnectionStatsRouterToServer::clear_seq_num_r2s() {
  _impl_.seq_num_r2s_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t CMsgSteamDatagramConnectionStatsRouterToServer::_internal_seq_num_r2s() const {
  return _impl_.seq_num_r2s_;
}
inline uint32_t CMsgSteamDatagramConnectionStatsRouterToServer::seq_num_r2s() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectionStatsRouterToServer.seq_num_r2s)
  return _internal_seq_num_r2s();
}
inline void CMsgSteamDatagramConnectionStatsRouterToServer::_internal_set_seq_num_r2s(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.seq_num_r2s_ = value;
}
inline void CMsgSteamDatagramConnectionStatsRouterToServer::set_seq_num_r2s(uint32_t value) {
  _internal_set_seq_num_r2s(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramConnectionStatsRouterToServer.seq_num_r2s)
}

// optional uint32 seq_num_e2e = 6;
inline bool CMsgSteamDatagramConnectionStatsRouterToServer::_internal_has_seq_num_e2e() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CMsgSteamDatagramConnectionStatsRouterToServer::has_seq_num_e2e() const {
  return _internal_has_seq_num_e2e();
}
inline void CMsgSteamDatagramConnectionStatsRouterToServer::clear_seq_num_e2e() {
  _impl_.seq_num_e2e_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline uint32_t CMsgSteamDatagramConnectionStatsRouterToServer::_internal_seq_num_e2e() const {
  return _impl_.seq_num_e2e_;
}
inline uint32_t CMsgSteamDatagramConnectionStatsRouterToServer::seq_num_e2e() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectionStatsRouterToServer.seq_num_e2e)
  return _internal_seq_num_e2e();
}
inline void CMsgSteamDatagramConnectionStatsRouterToServer::_internal_set_seq_num_e2e(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.seq_num_e2e_ = value;
}
inline void CMsgSteamDatagramConnectionStatsRouterToServer::set_seq_num_e2e(uint32_t value) {
  _internal_set_seq_num_e2e(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramConnectionStatsRouterToServer.seq_num_e2e)
}

// optional string client_identity_string = 15;
inline bool CMsgSteamDatagramConnectionStatsRouterToServer::_internal_has_client_identity_string() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgSteamDatagramConnectionStatsRouterToServer::has_client_identity_string() const {
  return _internal_has_client_identity_string();
}
inline void CMsgSteamDatagramConnectionStatsRouterToServer::clear_client_identity_string() {
  _impl_.client_identity_string_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CMsgSteamDatagramConnectionStatsRouterToServer::client_identity_string() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectionStatsRouterToServer.client_identity_string)
  return _internal_client_identity_string();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgSteamDatagramConnectionStatsRouterToServer::set_client_identity_string(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.client_identity_string_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramConnectionStatsRouterToServer.client_identity_string)
}
inline std::string* CMsgSteamDatagramConnectionStatsRouterToServer::mutable_client_identity_string() {
  std::string* _s = _internal_mutable_client_identity_string();
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramConnectionStatsRouterToServer.client_identity_string)
  return _s;
}
inline const std::string& CMsgSteamDatagramConnectionStatsRouterToServer::_internal_client_identity_string() const {
  return _impl_.client_identity_string_.Get();
}
inline void CMsgSteamDatagramConnectionStatsRouterToServer::_internal_set_client_identity_string(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.client_identity_string_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramConnectionStatsRouterToServer::_internal_mutable_client_identity_string() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.client_identity_string_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramConnectionStatsRouterToServer::release_client_identity_string() {
  // @@protoc_insertion_point(field_release:CMsgSteamDatagramConnectionStatsRouterToServer.client_identity_string)
  if (!_internal_has_client_identity_string()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.client_identity_string_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.client_identity_string_.IsDefault()) {
    _impl_.client_identity_string_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgSteamDatagramConnectionStatsRouterToServer::set_allocated_client_identity_string(std::string* client_identity_string) {
  if (client_identity_string != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.client_identity_string_.SetAllocated(client_identity_string, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.client_identity_string_.IsDefault()) {
    _impl_.client_identity_string_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamDatagramConnectionStatsRouterToServer.client_identity_string)
}

// optional fixed64 legacy_client_steam_id = 7;
inline bool CMsgSteamDatagramConnectionStatsRouterToServer::_internal_has_legacy_client_steam_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool CMsgSteamDatagramConnectionStatsRouterToServer::has_legacy_client_steam_id() const {
  return _internal_has_legacy_client_steam_id();
}
inline void CMsgSteamDatagramConnectionStatsRouterToServer::clear_legacy_client_steam_id() {
  _impl_.legacy_client_steam_id_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline uint64_t CMsgSteamDatagramConnectionStatsRouterToServer::_internal_legacy_client_steam_id() const {
  return _impl_.legacy_client_steam_id_;
}
inline uint64_t CMsgSteamDatagramConnectionStatsRouterToServer::legacy_client_steam_id() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectionStatsRouterToServer.legacy_client_steam_id)
  return _internal_legacy_client_steam_id();
}
inline void CMsgSteamDatagramConnectionStatsRouterToServer::_internal_set_legacy_client_steam_id(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.legacy_client_steam_id_ = value;
}
inline void CMsgSteamDatagramConnectionStatsRouterToServer::set_legacy_client_steam_id(uint64_t value) {
  _internal_set_legacy_client_steam_id(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramConnectionStatsRouterToServer.legacy_client_steam_id)
}

// optional uint32 relay_session_id = 8;
inline bool CMsgSteamDatagramConnectionStatsRouterToServer::_internal_has_relay_session_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool CMsgSteamDatagramConnectionStatsRouterToServer::has_relay_session_id() const {
  return _internal_has_relay_session_id();
}
inline void CMsgSteamDatagramConnectionStatsRouterToServer::clear_relay_session_id() {
  _impl_.relay_session_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline uint32_t CMsgSteamDatagramConnectionStatsRouterToServer::_internal_relay_session_id() const {
  return _impl_.relay_session_id_;
}
inline uint32_t CMsgSteamDatagramConnectionStatsRouterToServer::relay_session_id() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectionStatsRouterToServer.relay_session_id)
  return _internal_relay_session_id();
}
inline void CMsgSteamDatagramConnectionStatsRouterToServer::_internal_set_relay_session_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.relay_session_id_ = value;
}
inline void CMsgSteamDatagramConnectionStatsRouterToServer::set_relay_session_id(uint32_t value) {
  _internal_set_relay_session_id(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramConnectionStatsRouterToServer.relay_session_id)
}

// optional fixed32 client_connection_id = 9;
inline bool CMsgSteamDatagramConnectionStatsRouterToServer::_internal_has_client_connection_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool CMsgSteamDatagramConnectionStatsRouterToServer::has_client_connection_id() const {
  return _internal_has_client_connection_id();
}
inline void CMsgSteamDatagramConnectionStatsRouterToServer::clear_client_connection_id() {
  _impl_.client_connection_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline uint32_t CMsgSteamDatagramConnectionStatsRouterToServer::_internal_client_connection_id() const {
  return _impl_.client_connection_id_;
}
inline uint32_t CMsgSteamDatagramConnectionStatsRouterToServer::client_connection_id() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectionStatsRouterToServer.client_connection_id)
  return _internal_client_connection_id();
}
inline void CMsgSteamDatagramConnectionStatsRouterToServer::_internal_set_client_connection_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.client_connection_id_ = value;
}
inline void CMsgSteamDatagramConnectionStatsRouterToServer::set_client_connection_id(uint32_t value) {
  _internal_set_client_connection_id(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramConnectionStatsRouterToServer.client_connection_id)
}

// optional fixed32 server_connection_id = 13;
inline bool CMsgSteamDatagramConnectionStatsRouterToServer::_internal_has_server_connection_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool CMsgSteamDatagramConnectionStatsRouterToServer::has_server_connection_id() const {
  return _internal_has_server_connection_id();
}
inline void CMsgSteamDatagramConnectionStatsRouterToServer::clear_server_connection_id() {
  _impl_.server_connection_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline uint32_t CMsgSteamDatagramConnectionStatsRouterToServer::_internal_server_connection_id() const {
  return _impl_.server_connection_id_;
}
inline uint32_t CMsgSteamDatagramConnectionStatsRouterToServer::server_connection_id() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectionStatsRouterToServer.server_connection_id)
  return _internal_server_connection_id();
}
inline void CMsgSteamDatagramConnectionStatsRouterToServer::_internal_set_server_connection_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.server_connection_id_ = value;
}
inline void CMsgSteamDatagramConnectionStatsRouterToServer::set_server_connection_id(uint32_t value) {
  _internal_set_server_connection_id(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramConnectionStatsRouterToServer.server_connection_id)
}

// optional fixed64 routing_secret = 14;
inline bool CMsgSteamDatagramConnectionStatsRouterToServer::_internal_has_routing_secret() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool CMsgSteamDatagramConnectionStatsRouterToServer::has_routing_secret() const {
  return _internal_has_routing_secret();
}
inline void CMsgSteamDatagramConnectionStatsRouterToServer::clear_routing_secret() {
  _impl_.routing_secret_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline uint64_t CMsgSteamDatagramConnectionStatsRouterToServer::_internal_routing_secret() const {
  return _impl_.routing_secret_;
}
inline uint64_t CMsgSteamDatagramConnectionStatsRouterToServer::routing_secret() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectionStatsRouterToServer.routing_secret)
  return _internal_routing_secret();
}
inline void CMsgSteamDatagramConnectionStatsRouterToServer::_internal_set_routing_secret(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000400u;
  _impl_.routing_secret_ = value;
}
inline void CMsgSteamDatagramConnectionStatsRouterToServer::set_routing_secret(uint64_t value) {
  _internal_set_routing_secret(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramConnectionStatsRouterToServer.routing_secret)
}

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

// CMsgSteamDatagramConnectionStatsServerToRouter

// optional .CMsgSteamDatagramConnectionQuality quality_relay = 1;
inline bool CMsgSteamDatagramConnectionStatsServerToRouter::_internal_has_quality_relay() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.quality_relay_ != nullptr);
  return value;
}
inline bool CMsgSteamDatagramConnectionStatsServerToRouter::has_quality_relay() const {
  return _internal_has_quality_relay();
}
inline const ::CMsgSteamDatagramConnectionQuality& CMsgSteamDatagramConnectionStatsServerToRouter::_internal_quality_relay() const {
  const ::CMsgSteamDatagramConnectionQuality* p = _impl_.quality_relay_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgSteamDatagramConnectionQuality&>(
      ::_CMsgSteamDatagramConnectionQuality_default_instance_);
}
inline const ::CMsgSteamDatagramConnectionQuality& CMsgSteamDatagramConnectionStatsServerToRouter::quality_relay() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectionStatsServerToRouter.quality_relay)
  return _internal_quality_relay();
}
inline void CMsgSteamDatagramConnectionStatsServerToRouter::unsafe_arena_set_allocated_quality_relay(
    ::CMsgSteamDatagramConnectionQuality* quality_relay) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.quality_relay_);
  }
  _impl_.quality_relay_ = quality_relay;
  if (quality_relay) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgSteamDatagramConnectionStatsServerToRouter.quality_relay)
}
inline ::CMsgSteamDatagramConnectionQuality* CMsgSteamDatagramConnectionStatsServerToRouter::release_quality_relay() {
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgSteamDatagramConnectionQuality* temp = _impl_.quality_relay_;
  _impl_.quality_relay_ = 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 ::CMsgSteamDatagramConnectionQuality* CMsgSteamDatagramConnectionStatsServerToRouter::unsafe_arena_release_quality_relay() {
  // @@protoc_insertion_point(field_release:CMsgSteamDatagramConnectionStatsServerToRouter.quality_relay)
  _impl_._has_bits_[0] &= ~0x00000001u;
  ::CMsgSteamDatagramConnectionQuality* temp = _impl_.quality_relay_;
  _impl_.quality_relay_ = nullptr;
  return temp;
}
inline ::CMsgSteamDatagramConnectionQuality* CMsgSteamDatagramConnectionStatsServerToRouter::_internal_mutable_quality_relay() {
  _impl_._has_bits_[0] |= 0x00000001u;
  if (_impl_.quality_relay_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgSteamDatagramConnectionQuality>(GetArenaForAllocation());
    _impl_.quality_relay_ = p;
  }
  return _impl_.quality_relay_;
}
inline ::CMsgSteamDatagramConnectionQuality* CMsgSteamDatagramConnectionStatsServerToRouter::mutable_quality_relay() {
  ::CMsgSteamDatagramConnectionQuality* _msg = _internal_mutable_quality_relay();
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramConnectionStatsServerToRouter.quality_relay)
  return _msg;
}
inline void CMsgSteamDatagramConnectionStatsServerToRouter::set_allocated_quality_relay(::CMsgSteamDatagramConnectionQuality* quality_relay) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.quality_relay_);
  }
  if (quality_relay) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(quality_relay));
    if (message_arena != submessage_arena) {
      quality_relay = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, quality_relay, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.quality_relay_ = quality_relay;
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamDatagramConnectionStatsServerToRouter.quality_relay)
}

// optional .CMsgSteamDatagramConnectionQuality quality_e2e = 2;
inline bool CMsgSteamDatagramConnectionStatsServerToRouter::_internal_has_quality_e2e() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.quality_e2e_ != nullptr);
  return value;
}
inline bool CMsgSteamDatagramConnectionStatsServerToRouter::has_quality_e2e() const {
  return _internal_has_quality_e2e();
}
inline const ::CMsgSteamDatagramConnectionQuality& CMsgSteamDatagramConnectionStatsServerToRouter::_internal_quality_e2e() const {
  const ::CMsgSteamDatagramConnectionQuality* p = _impl_.quality_e2e_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgSteamDatagramConnectionQuality&>(
      ::_CMsgSteamDatagramConnectionQuality_default_instance_);
}
inline const ::CMsgSteamDatagramConnectionQuality& CMsgSteamDatagramConnectionStatsServerToRouter::quality_e2e() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectionStatsServerToRouter.quality_e2e)
  return _internal_quality_e2e();
}
inline void CMsgSteamDatagramConnectionStatsServerToRouter::unsafe_arena_set_allocated_quality_e2e(
    ::CMsgSteamDatagramConnectionQuality* quality_e2e) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.quality_e2e_);
  }
  _impl_.quality_e2e_ = quality_e2e;
  if (quality_e2e) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgSteamDatagramConnectionStatsServerToRouter.quality_e2e)
}
inline ::CMsgSteamDatagramConnectionQuality* CMsgSteamDatagramConnectionStatsServerToRouter::release_quality_e2e() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgSteamDatagramConnectionQuality* temp = _impl_.quality_e2e_;
  _impl_.quality_e2e_ = 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 ::CMsgSteamDatagramConnectionQuality* CMsgSteamDatagramConnectionStatsServerToRouter::unsafe_arena_release_quality_e2e() {
  // @@protoc_insertion_point(field_release:CMsgSteamDatagramConnectionStatsServerToRouter.quality_e2e)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgSteamDatagramConnectionQuality* temp = _impl_.quality_e2e_;
  _impl_.quality_e2e_ = nullptr;
  return temp;
}
inline ::CMsgSteamDatagramConnectionQuality* CMsgSteamDatagramConnectionStatsServerToRouter::_internal_mutable_quality_e2e() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.quality_e2e_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgSteamDatagramConnectionQuality>(GetArenaForAllocation());
    _impl_.quality_e2e_ = p;
  }
  return _impl_.quality_e2e_;
}
inline ::CMsgSteamDatagramConnectionQuality* CMsgSteamDatagramConnectionStatsServerToRouter::mutable_quality_e2e() {
  ::CMsgSteamDatagramConnectionQuality* _msg = _internal_mutable_quality_e2e();
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramConnectionStatsServerToRouter.quality_e2e)
  return _msg;
}
inline void CMsgSteamDatagramConnectionStatsServerToRouter::set_allocated_quality_e2e(::CMsgSteamDatagramConnectionQuality* quality_e2e) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.quality_e2e_);
  }
  if (quality_e2e) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(quality_e2e));
    if (message_arena != submessage_arena) {
      quality_e2e = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, quality_e2e, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.quality_e2e_ = quality_e2e;
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamDatagramConnectionStatsServerToRouter.quality_e2e)
}

// repeated fixed32 ack_relay = 8;
inline int CMsgSteamDatagramConnectionStatsServerToRouter::_internal_ack_relay_size() const {
  return _impl_.ack_relay_.size();
}
inline int CMsgSteamDatagramConnectionStatsServerToRouter::ack_relay_size() const {
  return _internal_ack_relay_size();
}
inline void CMsgSteamDatagramConnectionStatsServerToRouter::clear_ack_relay() {
  _impl_.ack_relay_.Clear();
}
inline uint32_t CMsgSteamDatagramConnectionStatsServerToRouter::_internal_ack_relay(int index) const {
  return _impl_.ack_relay_.Get(index);
}
inline uint32_t CMsgSteamDatagramConnectionStatsServerToRouter::ack_relay(int index) const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectionStatsServerToRouter.ack_relay)
  return _internal_ack_relay(index);
}
inline void CMsgSteamDatagramConnectionStatsServerToRouter::set_ack_relay(int index, uint32_t value) {
  _impl_.ack_relay_.Set(index, value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramConnectionStatsServerToRouter.ack_relay)
}
inline void CMsgSteamDatagramConnectionStatsServerToRouter::_internal_add_ack_relay(uint32_t value) {
  _impl_.ack_relay_.Add(value);
}
inline void CMsgSteamDatagramConnectionStatsServerToRouter::add_ack_relay(uint32_t value) {
  _internal_add_ack_relay(value);
  // @@protoc_insertion_point(field_add:CMsgSteamDatagramConnectionStatsServerToRouter.ack_relay)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
CMsgSteamDatagramConnectionStatsServerToRouter::_internal_ack_relay() const {
  return _impl_.ack_relay_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
CMsgSteamDatagramConnectionStatsServerToRouter::ack_relay() const {
  // @@protoc_insertion_point(field_list:CMsgSteamDatagramConnectionStatsServerToRouter.ack_relay)
  return _internal_ack_relay();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
CMsgSteamDatagramConnectionStatsServerToRouter::_internal_mutable_ack_relay() {
  return &_impl_.ack_relay_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
CMsgSteamDatagramConnectionStatsServerToRouter::mutable_ack_relay() {
  // @@protoc_insertion_point(field_mutable_list:CMsgSteamDatagramConnectionStatsServerToRouter.ack_relay)
  return _internal_mutable_ack_relay();
}

// repeated fixed32 legacy_ack_e2e = 9;
inline int CMsgSteamDatagramConnectionStatsServerToRouter::_internal_legacy_ack_e2e_size() const {
  return _impl_.legacy_ack_e2e_.size();
}
inline int CMsgSteamDatagramConnectionStatsServerToRouter::legacy_ack_e2e_size() const {
  return _internal_legacy_ack_e2e_size();
}
inline void CMsgSteamDatagramConnectionStatsServerToRouter::clear_legacy_ack_e2e() {
  _impl_.legacy_ack_e2e_.Clear();
}
inline uint32_t CMsgSteamDatagramConnectionStatsServerToRouter::_internal_legacy_ack_e2e(int index) const {
  return _impl_.legacy_ack_e2e_.Get(index);
}
inline uint32_t CMsgSteamDatagramConnectionStatsServerToRouter::legacy_ack_e2e(int index) const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectionStatsServerToRouter.legacy_ack_e2e)
  return _internal_legacy_ack_e2e(index);
}
inline void CMsgSteamDatagramConnectionStatsServerToRouter::set_legacy_ack_e2e(int index, uint32_t value) {
  _impl_.legacy_ack_e2e_.Set(index, value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramConnectionStatsServerToRouter.legacy_ack_e2e)
}
inline void CMsgSteamDatagramConnectionStatsServerToRouter::_internal_add_legacy_ack_e2e(uint32_t value) {
  _impl_.legacy_ack_e2e_.Add(value);
}
inline void CMsgSteamDatagramConnectionStatsServerToRouter::add_legacy_ack_e2e(uint32_t value) {
  _internal_add_legacy_ack_e2e(value);
  // @@protoc_insertion_point(field_add:CMsgSteamDatagramConnectionStatsServerToRouter.legacy_ack_e2e)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
CMsgSteamDatagramConnectionStatsServerToRouter::_internal_legacy_ack_e2e() const {
  return _impl_.legacy_ack_e2e_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
CMsgSteamDatagramConnectionStatsServerToRouter::legacy_ack_e2e() const {
  // @@protoc_insertion_point(field_list:CMsgSteamDatagramConnectionStatsServerToRouter.legacy_ack_e2e)
  return _internal_legacy_ack_e2e();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
CMsgSteamDatagramConnectionStatsServerToRouter::_internal_mutable_legacy_ack_e2e() {
  return &_impl_.legacy_ack_e2e_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
CMsgSteamDatagramConnectionStatsServerToRouter::mutable_legacy_ack_e2e() {
  // @@protoc_insertion_point(field_mutable_list:CMsgSteamDatagramConnectionStatsServerToRouter.legacy_ack_e2e)
  return _internal_mutable_legacy_ack_e2e();
}

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

// optional uint32 seq_num_s2r = 3;
inline bool CMsgSteamDatagramConnectionStatsServerToRouter::_internal_has_seq_num_s2r() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgSteamDatagramConnectionStatsServerToRouter::has_seq_num_s2r() const {
  return _internal_has_seq_num_s2r();
}
inline void CMsgSteamDatagramConnectionStatsServerToRouter::clear_seq_num_s2r() {
  _impl_.seq_num_s2r_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t CMsgSteamDatagramConnectionStatsServerToRouter::_internal_seq_num_s2r() const {
  return _impl_.seq_num_s2r_;
}
inline uint32_t CMsgSteamDatagramConnectionStatsServerToRouter::seq_num_s2r() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectionStatsServerToRouter.seq_num_s2r)
  return _internal_seq_num_s2r();
}
inline void CMsgSteamDatagramConnectionStatsServerToRouter::_internal_set_seq_num_s2r(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.seq_num_s2r_ = value;
}
inline void CMsgSteamDatagramConnectionStatsServerToRouter::set_seq_num_s2r(uint32_t value) {
  _internal_set_seq_num_s2r(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramConnectionStatsServerToRouter.seq_num_s2r)
}

// optional uint32 seq_num_e2e = 4;
inline bool CMsgSteamDatagramConnectionStatsServerToRouter::_internal_has_seq_num_e2e() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CMsgSteamDatagramConnectionStatsServerToRouter::has_seq_num_e2e() const {
  return _internal_has_seq_num_e2e();
}
inline void CMsgSteamDatagramConnectionStatsServerToRouter::clear_seq_num_e2e() {
  _impl_.seq_num_e2e_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t CMsgSteamDatagramConnectionStatsServerToRouter::_internal_seq_num_e2e() const {
  return _impl_.seq_num_e2e_;
}
inline uint32_t CMsgSteamDatagramConnectionStatsServerToRouter::seq_num_e2e() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectionStatsServerToRouter.seq_num_e2e)
  return _internal_seq_num_e2e();
}
inline void CMsgSteamDatagramConnectionStatsServerToRouter::_internal_set_seq_num_e2e(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.seq_num_e2e_ = value;
}
inline void CMsgSteamDatagramConnectionStatsServerToRouter::set_seq_num_e2e(uint32_t value) {
  _internal_set_seq_num_e2e(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramConnectionStatsServerToRouter.seq_num_e2e)
}

// optional uint32 relay_session_id = 6;
inline bool CMsgSteamDatagramConnectionStatsServerToRouter::_internal_has_relay_session_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CMsgSteamDatagramConnectionStatsServerToRouter::has_relay_session_id() const {
  return _internal_has_relay_session_id();
}
inline void CMsgSteamDatagramConnectionStatsServerToRouter::clear_relay_session_id() {
  _impl_.relay_session_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline uint32_t CMsgSteamDatagramConnectionStatsServerToRouter::_internal_relay_session_id() const {
  return _impl_.relay_session_id_;
}
inline uint32_t CMsgSteamDatagramConnectionStatsServerToRouter::relay_session_id() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectionStatsServerToRouter.relay_session_id)
  return _internal_relay_session_id();
}
inline void CMsgSteamDatagramConnectionStatsServerToRouter::_internal_set_relay_session_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.relay_session_id_ = value;
}
inline void CMsgSteamDatagramConnectionStatsServerToRouter::set_relay_session_id(uint32_t value) {
  _internal_set_relay_session_id(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramConnectionStatsServerToRouter.relay_session_id)
}

// optional fixed32 client_connection_id = 7;
inline bool CMsgSteamDatagramConnectionStatsServerToRouter::_internal_has_client_connection_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool CMsgSteamDatagramConnectionStatsServerToRouter::has_client_connection_id() const {
  return _internal_has_client_connection_id();
}
inline void CMsgSteamDatagramConnectionStatsServerToRouter::clear_client_connection_id() {
  _impl_.client_connection_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline uint32_t CMsgSteamDatagramConnectionStatsServerToRouter::_internal_client_connection_id() const {
  return _impl_.client_connection_id_;
}
inline uint32_t CMsgSteamDatagramConnectionStatsServerToRouter::client_connection_id() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectionStatsServerToRouter.client_connection_id)
  return _internal_client_connection_id();
}
inline void CMsgSteamDatagramConnectionStatsServerToRouter::_internal_set_client_connection_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.client_connection_id_ = value;
}
inline void CMsgSteamDatagramConnectionStatsServerToRouter::set_client_connection_id(uint32_t value) {
  _internal_set_client_connection_id(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramConnectionStatsServerToRouter.client_connection_id)
}

// optional fixed32 server_connection_id = 11;
inline bool CMsgSteamDatagramConnectionStatsServerToRouter::_internal_has_server_connection_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool CMsgSteamDatagramConnectionStatsServerToRouter::has_server_connection_id() const {
  return _internal_has_server_connection_id();
}
inline void CMsgSteamDatagramConnectionStatsServerToRouter::clear_server_connection_id() {
  _impl_.server_connection_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline uint32_t CMsgSteamDatagramConnectionStatsServerToRouter::_internal_server_connection_id() const {
  return _impl_.server_connection_id_;
}
inline uint32_t CMsgSteamDatagramConnectionStatsServerToRouter::server_connection_id() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectionStatsServerToRouter.server_connection_id)
  return _internal_server_connection_id();
}
inline void CMsgSteamDatagramConnectionStatsServerToRouter::_internal_set_server_connection_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.server_connection_id_ = value;
}
inline void CMsgSteamDatagramConnectionStatsServerToRouter::set_server_connection_id(uint32_t value) {
  _internal_set_server_connection_id(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramConnectionStatsServerToRouter.server_connection_id)
}

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

// CMsgSteamDatagramP2PSessionRequestBody_EncryptedData

// optional string peer_identity_string = 1;
inline bool CMsgSteamDatagramP2PSessionRequestBody_EncryptedData::_internal_has_peer_identity_string() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgSteamDatagramP2PSessionRequestBody_EncryptedData::has_peer_identity_string() const {
  return _internal_has_peer_identity_string();
}
inline void CMsgSteamDatagramP2PSessionRequestBody_EncryptedData::clear_peer_identity_string() {
  _impl_.peer_identity_string_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CMsgSteamDatagramP2PSessionRequestBody_EncryptedData::peer_identity_string() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramP2PSessionRequestBody.EncryptedData.peer_identity_string)
  return _internal_peer_identity_string();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgSteamDatagramP2PSessionRequestBody_EncryptedData::set_peer_identity_string(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.peer_identity_string_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramP2PSessionRequestBody.EncryptedData.peer_identity_string)
}
inline std::string* CMsgSteamDatagramP2PSessionRequestBody_EncryptedData::mutable_peer_identity_string() {
  std::string* _s = _internal_mutable_peer_identity_string();
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramP2PSessionRequestBody.EncryptedData.peer_identity_string)
  return _s;
}
inline const std::string& CMsgSteamDatagramP2PSessionRequestBody_EncryptedData::_internal_peer_identity_string() const {
  return _impl_.peer_identity_string_.Get();
}
inline void CMsgSteamDatagramP2PSessionRequestBody_EncryptedData::_internal_set_peer_identity_string(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.peer_identity_string_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramP2PSessionRequestBody_EncryptedData::_internal_mutable_peer_identity_string() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.peer_identity_string_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramP2PSessionRequestBody_EncryptedData::release_peer_identity_string() {
  // @@protoc_insertion_point(field_release:CMsgSteamDatagramP2PSessionRequestBody.EncryptedData.peer_identity_string)
  if (!_internal_has_peer_identity_string()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.peer_identity_string_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.peer_identity_string_.IsDefault()) {
    _impl_.peer_identity_string_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgSteamDatagramP2PSessionRequestBody_EncryptedData::set_allocated_peer_identity_string(std::string* peer_identity_string) {
  if (peer_identity_string != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.peer_identity_string_.SetAllocated(peer_identity_string, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.peer_identity_string_.IsDefault()) {
    _impl_.peer_identity_string_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamDatagramP2PSessionRequestBody.EncryptedData.peer_identity_string)
}

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

// CMsgSteamDatagramP2PSessionRequestBody

// optional fixed32 challenge_time = 1;
inline bool CMsgSteamDatagramP2PSessionRequestBody::_internal_has_challenge_time() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool CMsgSteamDatagramP2PSessionRequestBody::has_challenge_time() const {
  return _internal_has_challenge_time();
}
inline void CMsgSteamDatagramP2PSessionRequestBody::clear_challenge_time() {
  _impl_.challenge_time_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline uint32_t CMsgSteamDatagramP2PSessionRequestBody::_internal_challenge_time() const {
  return _impl_.challenge_time_;
}
inline uint32_t CMsgSteamDatagramP2PSessionRequestBody::challenge_time() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramP2PSessionRequestBody.challenge_time)
  return _internal_challenge_time();
}
inline void CMsgSteamDatagramP2PSessionRequestBody::_internal_set_challenge_time(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.challenge_time_ = value;
}
inline void CMsgSteamDatagramP2PSessionRequestBody::set_challenge_time(uint32_t value) {
  _internal_set_challenge_time(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramP2PSessionRequestBody.challenge_time)
}

// optional fixed64 challenge = 2;
inline bool CMsgSteamDatagramP2PSessionRequestBody::_internal_has_challenge() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool CMsgSteamDatagramP2PSessionRequestBody::has_challenge() const {
  return _internal_has_challenge();
}
inline void CMsgSteamDatagramP2PSessionRequestBody::clear_challenge() {
  _impl_.challenge_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline uint64_t CMsgSteamDatagramP2PSessionRequestBody::_internal_challenge() const {
  return _impl_.challenge_;
}
inline uint64_t CMsgSteamDatagramP2PSessionRequestBody::challenge() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramP2PSessionRequestBody.challenge)
  return _internal_challenge();
}
inline void CMsgSteamDatagramP2PSessionRequestBody::_internal_set_challenge(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.challenge_ = value;
}
inline void CMsgSteamDatagramP2PSessionRequestBody::set_challenge(uint64_t value) {
  _internal_set_challenge(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramP2PSessionRequestBody.challenge)
}

// optional fixed32 client_connection_id = 3;
inline bool CMsgSteamDatagramP2PSessionRequestBody::_internal_has_client_connection_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool CMsgSteamDatagramP2PSessionRequestBody::has_client_connection_id() const {
  return _internal_has_client_connection_id();
}
inline void CMsgSteamDatagramP2PSessionRequestBody::clear_client_connection_id() {
  _impl_.client_connection_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000080u;
}
inline uint32_t CMsgSteamDatagramP2PSessionRequestBody::_internal_client_connection_id() const {
  return _impl_.client_connection_id_;
}
inline uint32_t CMsgSteamDatagramP2PSessionRequestBody::client_connection_id() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramP2PSessionRequestBody.client_connection_id)
  return _internal_client_connection_id();
}
inline void CMsgSteamDatagramP2PSessionRequestBody::_internal_set_client_connection_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000080u;
  _impl_.client_connection_id_ = value;
}
inline void CMsgSteamDatagramP2PSessionRequestBody::set_client_connection_id(uint32_t value) {
  _internal_set_client_connection_id(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramP2PSessionRequestBody.client_connection_id)
}

// optional fixed64 legacy_peer_steam_id = 4;
inline bool CMsgSteamDatagramP2PSessionRequestBody::_internal_has_legacy_peer_steam_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool CMsgSteamDatagramP2PSessionRequestBody::has_legacy_peer_steam_id() const {
  return _internal_has_legacy_peer_steam_id();
}
inline void CMsgSteamDatagramP2PSessionRequestBody::clear_legacy_peer_steam_id() {
  _impl_.legacy_peer_steam_id_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline uint64_t CMsgSteamDatagramP2PSessionRequestBody::_internal_legacy_peer_steam_id() const {
  return _impl_.legacy_peer_steam_id_;
}
inline uint64_t CMsgSteamDatagramP2PSessionRequestBody::legacy_peer_steam_id() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramP2PSessionRequestBody.legacy_peer_steam_id)
  return _internal_legacy_peer_steam_id();
}
inline void CMsgSteamDatagramP2PSessionRequestBody::_internal_set_legacy_peer_steam_id(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.legacy_peer_steam_id_ = value;
}
inline void CMsgSteamDatagramP2PSessionRequestBody::set_legacy_peer_steam_id(uint64_t value) {
  _internal_set_legacy_peer_steam_id(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramP2PSessionRequestBody.legacy_peer_steam_id)
}

// optional string peer_identity_string = 11;
inline bool CMsgSteamDatagramP2PSessionRequestBody::_internal_has_peer_identity_string() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgSteamDatagramP2PSessionRequestBody::has_peer_identity_string() const {
  return _internal_has_peer_identity_string();
}
inline void CMsgSteamDatagramP2PSessionRequestBody::clear_peer_identity_string() {
  _impl_.peer_identity_string_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CMsgSteamDatagramP2PSessionRequestBody::peer_identity_string() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramP2PSessionRequestBody.peer_identity_string)
  return _internal_peer_identity_string();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgSteamDatagramP2PSessionRequestBody::set_peer_identity_string(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.peer_identity_string_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramP2PSessionRequestBody.peer_identity_string)
}
inline std::string* CMsgSteamDatagramP2PSessionRequestBody::mutable_peer_identity_string() {
  std::string* _s = _internal_mutable_peer_identity_string();
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramP2PSessionRequestBody.peer_identity_string)
  return _s;
}
inline const std::string& CMsgSteamDatagramP2PSessionRequestBody::_internal_peer_identity_string() const {
  return _impl_.peer_identity_string_.Get();
}
inline void CMsgSteamDatagramP2PSessionRequestBody::_internal_set_peer_identity_string(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.peer_identity_string_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramP2PSessionRequestBody::_internal_mutable_peer_identity_string() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.peer_identity_string_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramP2PSessionRequestBody::release_peer_identity_string() {
  // @@protoc_insertion_point(field_release:CMsgSteamDatagramP2PSessionRequestBody.peer_identity_string)
  if (!_internal_has_peer_identity_string()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.peer_identity_string_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.peer_identity_string_.IsDefault()) {
    _impl_.peer_identity_string_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgSteamDatagramP2PSessionRequestBody::set_allocated_peer_identity_string(std::string* peer_identity_string) {
  if (peer_identity_string != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.peer_identity_string_.SetAllocated(peer_identity_string, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.peer_identity_string_.IsDefault()) {
    _impl_.peer_identity_string_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamDatagramP2PSessionRequestBody.peer_identity_string)
}

// optional fixed32 peer_connection_id = 5;
inline bool CMsgSteamDatagramP2PSessionRequestBody::_internal_has_peer_connection_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool CMsgSteamDatagramP2PSessionRequestBody::has_peer_connection_id() const {
  return _internal_has_peer_connection_id();
}
inline void CMsgSteamDatagramP2PSessionRequestBody::clear_peer_connection_id() {
  _impl_.peer_connection_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline uint32_t CMsgSteamDatagramP2PSessionRequestBody::_internal_peer_connection_id() const {
  return _impl_.peer_connection_id_;
}
inline uint32_t CMsgSteamDatagramP2PSessionRequestBody::peer_connection_id() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramP2PSessionRequestBody.peer_connection_id)
  return _internal_peer_connection_id();
}
inline void CMsgSteamDatagramP2PSessionRequestBody::_internal_set_peer_connection_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.peer_connection_id_ = value;
}
inline void CMsgSteamDatagramP2PSessionRequestBody::set_peer_connection_id(uint32_t value) {
  _internal_set_peer_connection_id(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramP2PSessionRequestBody.peer_connection_id)
}

// optional bytes encrypted_data = 14;
inline bool CMsgSteamDatagramP2PSessionRequestBody::_internal_has_encrypted_data() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CMsgSteamDatagramP2PSessionRequestBody::has_encrypted_data() const {
  return _internal_has_encrypted_data();
}
inline void CMsgSteamDatagramP2PSessionRequestBody::clear_encrypted_data() {
  _impl_.encrypted_data_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline const std::string& CMsgSteamDatagramP2PSessionRequestBody::encrypted_data() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramP2PSessionRequestBody.encrypted_data)
  return _internal_encrypted_data();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgSteamDatagramP2PSessionRequestBody::set_encrypted_data(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000008u;
 _impl_.encrypted_data_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramP2PSessionRequestBody.encrypted_data)
}
inline std::string* CMsgSteamDatagramP2PSessionRequestBody::mutable_encrypted_data() {
  std::string* _s = _internal_mutable_encrypted_data();
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramP2PSessionRequestBody.encrypted_data)
  return _s;
}
inline const std::string& CMsgSteamDatagramP2PSessionRequestBody::_internal_encrypted_data() const {
  return _impl_.encrypted_data_.Get();
}
inline void CMsgSteamDatagramP2PSessionRequestBody::_internal_set_encrypted_data(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.encrypted_data_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramP2PSessionRequestBody::_internal_mutable_encrypted_data() {
  _impl_._has_bits_[0] |= 0x00000008u;
  return _impl_.encrypted_data_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramP2PSessionRequestBody::release_encrypted_data() {
  // @@protoc_insertion_point(field_release:CMsgSteamDatagramP2PSessionRequestBody.encrypted_data)
  if (!_internal_has_encrypted_data()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000008u;
  auto* p = _impl_.encrypted_data_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.encrypted_data_.IsDefault()) {
    _impl_.encrypted_data_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgSteamDatagramP2PSessionRequestBody::set_allocated_encrypted_data(std::string* encrypted_data) {
  if (encrypted_data != nullptr) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.encrypted_data_.SetAllocated(encrypted_data, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.encrypted_data_.IsDefault()) {
    _impl_.encrypted_data_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamDatagramP2PSessionRequestBody.encrypted_data)
}

// optional uint32 encryption_your_public_key_lead_byte = 15;
inline bool CMsgSteamDatagramP2PSessionRequestBody::_internal_has_encryption_your_public_key_lead_byte() const {
  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
  return value;
}
inline bool CMsgSteamDatagramP2PSessionRequestBody::has_encryption_your_public_key_lead_byte() const {
  return _internal_has_encryption_your_public_key_lead_byte();
}
inline void CMsgSteamDatagramP2PSessionRequestBody::clear_encryption_your_public_key_lead_byte() {
  _impl_.encryption_your_public_key_lead_byte_ = 0u;
  _impl_._has_bits_[0] &= ~0x00001000u;
}
inline uint32_t CMsgSteamDatagramP2PSessionRequestBody::_internal_encryption_your_public_key_lead_byte() const {
  return _impl_.encryption_your_public_key_lead_byte_;
}
inline uint32_t CMsgSteamDatagramP2PSessionRequestBody::encryption_your_public_key_lead_byte() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramP2PSessionRequestBody.encryption_your_public_key_lead_byte)
  return _internal_encryption_your_public_key_lead_byte();
}
inline void CMsgSteamDatagramP2PSessionRequestBody::_internal_set_encryption_your_public_key_lead_byte(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00001000u;
  _impl_.encryption_your_public_key_lead_byte_ = value;
}
inline void CMsgSteamDatagramP2PSessionRequestBody::set_encryption_your_public_key_lead_byte(uint32_t value) {
  _internal_set_encryption_your_public_key_lead_byte(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramP2PSessionRequestBody.encryption_your_public_key_lead_byte)
}

// optional bytes encryption_my_ephemeral_public_key = 16;
inline bool CMsgSteamDatagramP2PSessionRequestBody::_internal_has_encryption_my_ephemeral_public_key() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CMsgSteamDatagramP2PSessionRequestBody::has_encryption_my_ephemeral_public_key() const {
  return _internal_has_encryption_my_ephemeral_public_key();
}
inline void CMsgSteamDatagramP2PSessionRequestBody::clear_encryption_my_ephemeral_public_key() {
  _impl_.encryption_my_ephemeral_public_key_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline const std::string& CMsgSteamDatagramP2PSessionRequestBody::encryption_my_ephemeral_public_key() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramP2PSessionRequestBody.encryption_my_ephemeral_public_key)
  return _internal_encryption_my_ephemeral_public_key();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgSteamDatagramP2PSessionRequestBody::set_encryption_my_ephemeral_public_key(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000010u;
 _impl_.encryption_my_ephemeral_public_key_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramP2PSessionRequestBody.encryption_my_ephemeral_public_key)
}
inline std::string* CMsgSteamDatagramP2PSessionRequestBody::mutable_encryption_my_ephemeral_public_key() {
  std::string* _s = _internal_mutable_encryption_my_ephemeral_public_key();
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramP2PSessionRequestBody.encryption_my_ephemeral_public_key)
  return _s;
}
inline const std::string& CMsgSteamDatagramP2PSessionRequestBody::_internal_encryption_my_ephemeral_public_key() const {
  return _impl_.encryption_my_ephemeral_public_key_.Get();
}
inline void CMsgSteamDatagramP2PSessionRequestBody::_internal_set_encryption_my_ephemeral_public_key(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.encryption_my_ephemeral_public_key_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramP2PSessionRequestBody::_internal_mutable_encryption_my_ephemeral_public_key() {
  _impl_._has_bits_[0] |= 0x00000010u;
  return _impl_.encryption_my_ephemeral_public_key_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramP2PSessionRequestBody::release_encryption_my_ephemeral_public_key() {
  // @@protoc_insertion_point(field_release:CMsgSteamDatagramP2PSessionRequestBody.encryption_my_ephemeral_public_key)
  if (!_internal_has_encryption_my_ephemeral_public_key()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000010u;
  auto* p = _impl_.encryption_my_ephemeral_public_key_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.encryption_my_ephemeral_public_key_.IsDefault()) {
    _impl_.encryption_my_ephemeral_public_key_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgSteamDatagramP2PSessionRequestBody::set_allocated_encryption_my_ephemeral_public_key(std::string* encryption_my_ephemeral_public_key) {
  if (encryption_my_ephemeral_public_key != nullptr) {
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  _impl_.encryption_my_ephemeral_public_key_.SetAllocated(encryption_my_ephemeral_public_key, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.encryption_my_ephemeral_public_key_.IsDefault()) {
    _impl_.encryption_my_ephemeral_public_key_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamDatagramP2PSessionRequestBody.encryption_my_ephemeral_public_key)
}

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

// optional uint64 network_config_version = 9;
inline bool CMsgSteamDatagramP2PSessionRequestBody::_internal_has_network_config_version() const {
  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
  return value;
}
inline bool CMsgSteamDatagramP2PSessionRequestBody::has_network_config_version() const {
  return _internal_has_network_config_version();
}
inline void CMsgSteamDatagramP2PSessionRequestBody::clear_network_config_version() {
  _impl_.network_config_version_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000800u;
}
inline uint64_t CMsgSteamDatagramP2PSessionRequestBody::_internal_network_config_version() const {
  return _impl_.network_config_version_;
}
inline uint64_t CMsgSteamDatagramP2PSessionRequestBody::network_config_version() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramP2PSessionRequestBody.network_config_version)
  return _internal_network_config_version();
}
inline void CMsgSteamDatagramP2PSessionRequestBody::_internal_set_network_config_version(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000800u;
  _impl_.network_config_version_ = value;
}
inline void CMsgSteamDatagramP2PSessionRequestBody::set_network_config_version(uint64_t value) {
  _internal_set_network_config_version(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramP2PSessionRequestBody.network_config_version)
}

// optional string platform = 12;
inline bool CMsgSteamDatagramP2PSessionRequestBody::_internal_has_platform() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgSteamDatagramP2PSessionRequestBody::has_platform() const {
  return _internal_has_platform();
}
inline void CMsgSteamDatagramP2PSessionRequestBody::clear_platform() {
  _impl_.platform_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& CMsgSteamDatagramP2PSessionRequestBody::platform() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramP2PSessionRequestBody.platform)
  return _internal_platform();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgSteamDatagramP2PSessionRequestBody::set_platform(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.platform_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramP2PSessionRequestBody.platform)
}
inline std::string* CMsgSteamDatagramP2PSessionRequestBody::mutable_platform() {
  std::string* _s = _internal_mutable_platform();
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramP2PSessionRequestBody.platform)
  return _s;
}
inline const std::string& CMsgSteamDatagramP2PSessionRequestBody::_internal_platform() const {
  return _impl_.platform_.Get();
}
inline void CMsgSteamDatagramP2PSessionRequestBody::_internal_set_platform(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.platform_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramP2PSessionRequestBody::_internal_mutable_platform() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.platform_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramP2PSessionRequestBody::release_platform() {
  // @@protoc_insertion_point(field_release:CMsgSteamDatagramP2PSessionRequestBody.platform)
  if (!_internal_has_platform()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.platform_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.platform_.IsDefault()) {
    _impl_.platform_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgSteamDatagramP2PSessionRequestBody::set_allocated_platform(std::string* platform) {
  if (platform != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.platform_.SetAllocated(platform, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.platform_.IsDefault()) {
    _impl_.platform_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamDatagramP2PSessionRequestBody.platform)
}

// optional string build = 13;
inline bool CMsgSteamDatagramP2PSessionRequestBody::_internal_has_build() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgSteamDatagramP2PSessionRequestBody::has_build() const {
  return _internal_has_build();
}
inline void CMsgSteamDatagramP2PSessionRequestBody::clear_build() {
  _impl_.build_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline const std::string& CMsgSteamDatagramP2PSessionRequestBody::build() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramP2PSessionRequestBody.build)
  return _internal_build();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgSteamDatagramP2PSessionRequestBody::set_build(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000004u;
 _impl_.build_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramP2PSessionRequestBody.build)
}
inline std::string* CMsgSteamDatagramP2PSessionRequestBody::mutable_build() {
  std::string* _s = _internal_mutable_build();
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramP2PSessionRequestBody.build)
  return _s;
}
inline const std::string& CMsgSteamDatagramP2PSessionRequestBody::_internal_build() const {
  return _impl_.build_.Get();
}
inline void CMsgSteamDatagramP2PSessionRequestBody::_internal_set_build(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.build_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramP2PSessionRequestBody::_internal_mutable_build() {
  _impl_._has_bits_[0] |= 0x00000004u;
  return _impl_.build_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramP2PSessionRequestBody::release_build() {
  // @@protoc_insertion_point(field_release:CMsgSteamDatagramP2PSessionRequestBody.build)
  if (!_internal_has_build()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000004u;
  auto* p = _impl_.build_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.build_.IsDefault()) {
    _impl_.build_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgSteamDatagramP2PSessionRequestBody::set_allocated_build(std::string* build) {
  if (build != nullptr) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.build_.SetAllocated(build, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.build_.IsDefault()) {
    _impl_.build_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamDatagramP2PSessionRequestBody.build)
}

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

// CMsgSteamDatagramP2PSessionRequest

// optional .CMsgSteamDatagramCertificateSigned cert = 1;
inline bool CMsgSteamDatagramP2PSessionRequest::_internal_has_cert() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.cert_ != nullptr);
  return value;
}
inline bool CMsgSteamDatagramP2PSessionRequest::has_cert() const {
  return _internal_has_cert();
}
inline const ::CMsgSteamDatagramCertificateSigned& CMsgSteamDatagramP2PSessionRequest::_internal_cert() const {
  const ::CMsgSteamDatagramCertificateSigned* p = _impl_.cert_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgSteamDatagramCertificateSigned&>(
      ::_CMsgSteamDatagramCertificateSigned_default_instance_);
}
inline const ::CMsgSteamDatagramCertificateSigned& CMsgSteamDatagramP2PSessionRequest::cert() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramP2PSessionRequest.cert)
  return _internal_cert();
}
inline void CMsgSteamDatagramP2PSessionRequest::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:CMsgSteamDatagramP2PSessionRequest.cert)
}
inline ::CMsgSteamDatagramCertificateSigned* CMsgSteamDatagramP2PSessionRequest::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* CMsgSteamDatagramP2PSessionRequest::unsafe_arena_release_cert() {
  // @@protoc_insertion_point(field_release:CMsgSteamDatagramP2PSessionRequest.cert)
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::CMsgSteamDatagramCertificateSigned* temp = _impl_.cert_;
  _impl_.cert_ = nullptr;
  return temp;
}
inline ::CMsgSteamDatagramCertificateSigned* CMsgSteamDatagramP2PSessionRequest::_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* CMsgSteamDatagramP2PSessionRequest::mutable_cert() {
  ::CMsgSteamDatagramCertificateSigned* _msg = _internal_mutable_cert();
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramP2PSessionRequest.cert)
  return _msg;
}
inline void CMsgSteamDatagramP2PSessionRequest::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:CMsgSteamDatagramP2PSessionRequest.cert)
}

// optional bytes body = 2;
inline bool CMsgSteamDatagramP2PSessionRequest::_internal_has_body() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgSteamDatagramP2PSessionRequest::has_body() const {
  return _internal_has_body();
}
inline void CMsgSteamDatagramP2PSessionRequest::clear_body() {
  _impl_.body_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CMsgSteamDatagramP2PSessionRequest::body() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramP2PSessionRequest.body)
  return _internal_body();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgSteamDatagramP2PSessionRequest::set_body(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.body_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramP2PSessionRequest.body)
}
inline std::string* CMsgSteamDatagramP2PSessionRequest::mutable_body() {
  std::string* _s = _internal_mutable_body();
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramP2PSessionRequest.body)
  return _s;
}
inline const std::string& CMsgSteamDatagramP2PSessionRequest::_internal_body() const {
  return _impl_.body_.Get();
}
inline void CMsgSteamDatagramP2PSessionRequest::_internal_set_body(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.body_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramP2PSessionRequest::_internal_mutable_body() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.body_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramP2PSessionRequest::release_body() {
  // @@protoc_insertion_point(field_release:CMsgSteamDatagramP2PSessionRequest.body)
  if (!_internal_has_body()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.body_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.body_.IsDefault()) {
    _impl_.body_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgSteamDatagramP2PSessionRequest::set_allocated_body(std::string* body) {
  if (body != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.body_.SetAllocated(body, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.body_.IsDefault()) {
    _impl_.body_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamDatagramP2PSessionRequest.body)
}

// optional bytes signature = 3;
inline bool CMsgSteamDatagramP2PSessionRequest::_internal_has_signature() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgSteamDatagramP2PSessionRequest::has_signature() const {
  return _internal_has_signature();
}
inline void CMsgSteamDatagramP2PSessionRequest::clear_signature() {
  _impl_.signature_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& CMsgSteamDatagramP2PSessionRequest::signature() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramP2PSessionRequest.signature)
  return _internal_signature();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgSteamDatagramP2PSessionRequest::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:CMsgSteamDatagramP2PSessionRequest.signature)
}
inline std::string* CMsgSteamDatagramP2PSessionRequest::mutable_signature() {
  std::string* _s = _internal_mutable_signature();
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramP2PSessionRequest.signature)
  return _s;
}
inline const std::string& CMsgSteamDatagramP2PSessionRequest::_internal_signature() const {
  return _impl_.signature_.Get();
}
inline void CMsgSteamDatagramP2PSessionRequest::_internal_set_signature(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.signature_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramP2PSessionRequest::_internal_mutable_signature() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.signature_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramP2PSessionRequest::release_signature() {
  // @@protoc_insertion_point(field_release:CMsgSteamDatagramP2PSessionRequest.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 CMsgSteamDatagramP2PSessionRequest::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:CMsgSteamDatagramP2PSessionRequest.signature)
}

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

// CMsgSteamDatagramP2PSessionEstablished

// optional fixed32 connection_id = 1;
inline bool CMsgSteamDatagramP2PSessionEstablished::_internal_has_connection_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgSteamDatagramP2PSessionEstablished::has_connection_id() const {
  return _internal_has_connection_id();
}
inline void CMsgSteamDatagramP2PSessionEstablished::clear_connection_id() {
  _impl_.connection_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t CMsgSteamDatagramP2PSessionEstablished::_internal_connection_id() const {
  return _impl_.connection_id_;
}
inline uint32_t CMsgSteamDatagramP2PSessionEstablished::connection_id() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramP2PSessionEstablished.connection_id)
  return _internal_connection_id();
}
inline void CMsgSteamDatagramP2PSessionEstablished::_internal_set_connection_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.connection_id_ = value;
}
inline void CMsgSteamDatagramP2PSessionEstablished::set_connection_id(uint32_t value) {
  _internal_set_connection_id(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramP2PSessionEstablished.connection_id)
}

// optional uint32 seconds_until_shutdown = 3;
inline bool CMsgSteamDatagramP2PSessionEstablished::_internal_has_seconds_until_shutdown() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgSteamDatagramP2PSessionEstablished::has_seconds_until_shutdown() const {
  return _internal_has_seconds_until_shutdown();
}
inline void CMsgSteamDatagramP2PSessionEstablished::clear_seconds_until_shutdown() {
  _impl_.seconds_until_shutdown_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t CMsgSteamDatagramP2PSessionEstablished::_internal_seconds_until_shutdown() const {
  return _impl_.seconds_until_shutdown_;
}
inline uint32_t CMsgSteamDatagramP2PSessionEstablished::seconds_until_shutdown() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramP2PSessionEstablished.seconds_until_shutdown)
  return _internal_seconds_until_shutdown();
}
inline void CMsgSteamDatagramP2PSessionEstablished::_internal_set_seconds_until_shutdown(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.seconds_until_shutdown_ = value;
}
inline void CMsgSteamDatagramP2PSessionEstablished::set_seconds_until_shutdown(uint32_t value) {
  _internal_set_seconds_until_shutdown(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramP2PSessionEstablished.seconds_until_shutdown)
}

// optional bytes relay_routing_token = 4;
inline bool CMsgSteamDatagramP2PSessionEstablished::_internal_has_relay_routing_token() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgSteamDatagramP2PSessionEstablished::has_relay_routing_token() const {
  return _internal_has_relay_routing_token();
}
inline void CMsgSteamDatagramP2PSessionEstablished::clear_relay_routing_token() {
  _impl_.relay_routing_token_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CMsgSteamDatagramP2PSessionEstablished::relay_routing_token() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramP2PSessionEstablished.relay_routing_token)
  return _internal_relay_routing_token();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgSteamDatagramP2PSessionEstablished::set_relay_routing_token(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.relay_routing_token_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramP2PSessionEstablished.relay_routing_token)
}
inline std::string* CMsgSteamDatagramP2PSessionEstablished::mutable_relay_routing_token() {
  std::string* _s = _internal_mutable_relay_routing_token();
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramP2PSessionEstablished.relay_routing_token)
  return _s;
}
inline const std::string& CMsgSteamDatagramP2PSessionEstablished::_internal_relay_routing_token() const {
  return _impl_.relay_routing_token_.Get();
}
inline void CMsgSteamDatagramP2PSessionEstablished::_internal_set_relay_routing_token(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.relay_routing_token_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramP2PSessionEstablished::_internal_mutable_relay_routing_token() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.relay_routing_token_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramP2PSessionEstablished::release_relay_routing_token() {
  // @@protoc_insertion_point(field_release:CMsgSteamDatagramP2PSessionEstablished.relay_routing_token)
  if (!_internal_has_relay_routing_token()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.relay_routing_token_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.relay_routing_token_.IsDefault()) {
    _impl_.relay_routing_token_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgSteamDatagramP2PSessionEstablished::set_allocated_relay_routing_token(std::string* relay_routing_token) {
  if (relay_routing_token != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.relay_routing_token_.SetAllocated(relay_routing_token, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.relay_routing_token_.IsDefault()) {
    _impl_.relay_routing_token_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamDatagramP2PSessionEstablished.relay_routing_token)
}

// optional uint32 seq_num_r2c = 5;
inline bool CMsgSteamDatagramP2PSessionEstablished::_internal_has_seq_num_r2c() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CMsgSteamDatagramP2PSessionEstablished::has_seq_num_r2c() const {
  return _internal_has_seq_num_r2c();
}
inline void CMsgSteamDatagramP2PSessionEstablished::clear_seq_num_r2c() {
  _impl_.seq_num_r2c_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t CMsgSteamDatagramP2PSessionEstablished::_internal_seq_num_r2c() const {
  return _impl_.seq_num_r2c_;
}
inline uint32_t CMsgSteamDatagramP2PSessionEstablished::seq_num_r2c() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramP2PSessionEstablished.seq_num_r2c)
  return _internal_seq_num_r2c();
}
inline void CMsgSteamDatagramP2PSessionEstablished::_internal_set_seq_num_r2c(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.seq_num_r2c_ = value;
}
inline void CMsgSteamDatagramP2PSessionEstablished::set_seq_num_r2c(uint32_t value) {
  _internal_set_seq_num_r2c(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramP2PSessionEstablished.seq_num_r2c)
}

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

// CMsgSteamDatagramConnectionStatsP2PClientToRouter

// optional .CMsgSteamDatagramConnectionQuality quality_relay = 1;
inline bool CMsgSteamDatagramConnectionStatsP2PClientToRouter::_internal_has_quality_relay() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.quality_relay_ != nullptr);
  return value;
}
inline bool CMsgSteamDatagramConnectionStatsP2PClientToRouter::has_quality_relay() const {
  return _internal_has_quality_relay();
}
inline const ::CMsgSteamDatagramConnectionQuality& CMsgSteamDatagramConnectionStatsP2PClientToRouter::_internal_quality_relay() const {
  const ::CMsgSteamDatagramConnectionQuality* p = _impl_.quality_relay_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgSteamDatagramConnectionQuality&>(
      ::_CMsgSteamDatagramConnectionQuality_default_instance_);
}
inline const ::CMsgSteamDatagramConnectionQuality& CMsgSteamDatagramConnectionStatsP2PClientToRouter::quality_relay() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectionStatsP2PClientToRouter.quality_relay)
  return _internal_quality_relay();
}
inline void CMsgSteamDatagramConnectionStatsP2PClientToRouter::unsafe_arena_set_allocated_quality_relay(
    ::CMsgSteamDatagramConnectionQuality* quality_relay) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.quality_relay_);
  }
  _impl_.quality_relay_ = quality_relay;
  if (quality_relay) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgSteamDatagramConnectionStatsP2PClientToRouter.quality_relay)
}
inline ::CMsgSteamDatagramConnectionQuality* CMsgSteamDatagramConnectionStatsP2PClientToRouter::release_quality_relay() {
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::CMsgSteamDatagramConnectionQuality* temp = _impl_.quality_relay_;
  _impl_.quality_relay_ = 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 ::CMsgSteamDatagramConnectionQuality* CMsgSteamDatagramConnectionStatsP2PClientToRouter::unsafe_arena_release_quality_relay() {
  // @@protoc_insertion_point(field_release:CMsgSteamDatagramConnectionStatsP2PClientToRouter.quality_relay)
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::CMsgSteamDatagramConnectionQuality* temp = _impl_.quality_relay_;
  _impl_.quality_relay_ = nullptr;
  return temp;
}
inline ::CMsgSteamDatagramConnectionQuality* CMsgSteamDatagramConnectionStatsP2PClientToRouter::_internal_mutable_quality_relay() {
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.quality_relay_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgSteamDatagramConnectionQuality>(GetArenaForAllocation());
    _impl_.quality_relay_ = p;
  }
  return _impl_.quality_relay_;
}
inline ::CMsgSteamDatagramConnectionQuality* CMsgSteamDatagramConnectionStatsP2PClientToRouter::mutable_quality_relay() {
  ::CMsgSteamDatagramConnectionQuality* _msg = _internal_mutable_quality_relay();
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramConnectionStatsP2PClientToRouter.quality_relay)
  return _msg;
}
inline void CMsgSteamDatagramConnectionStatsP2PClientToRouter::set_allocated_quality_relay(::CMsgSteamDatagramConnectionQuality* quality_relay) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.quality_relay_);
  }
  if (quality_relay) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(quality_relay));
    if (message_arena != submessage_arena) {
      quality_relay = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, quality_relay, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.quality_relay_ = quality_relay;
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamDatagramConnectionStatsP2PClientToRouter.quality_relay)
}

// optional .CMsgSteamDatagramConnectionQuality quality_e2e = 2;
inline bool CMsgSteamDatagramConnectionStatsP2PClientToRouter::_internal_has_quality_e2e() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.quality_e2e_ != nullptr);
  return value;
}
inline bool CMsgSteamDatagramConnectionStatsP2PClientToRouter::has_quality_e2e() const {
  return _internal_has_quality_e2e();
}
inline const ::CMsgSteamDatagramConnectionQuality& CMsgSteamDatagramConnectionStatsP2PClientToRouter::_internal_quality_e2e() const {
  const ::CMsgSteamDatagramConnectionQuality* p = _impl_.quality_e2e_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgSteamDatagramConnectionQuality&>(
      ::_CMsgSteamDatagramConnectionQuality_default_instance_);
}
inline const ::CMsgSteamDatagramConnectionQuality& CMsgSteamDatagramConnectionStatsP2PClientToRouter::quality_e2e() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectionStatsP2PClientToRouter.quality_e2e)
  return _internal_quality_e2e();
}
inline void CMsgSteamDatagramConnectionStatsP2PClientToRouter::unsafe_arena_set_allocated_quality_e2e(
    ::CMsgSteamDatagramConnectionQuality* quality_e2e) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.quality_e2e_);
  }
  _impl_.quality_e2e_ = quality_e2e;
  if (quality_e2e) {
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgSteamDatagramConnectionStatsP2PClientToRouter.quality_e2e)
}
inline ::CMsgSteamDatagramConnectionQuality* CMsgSteamDatagramConnectionStatsP2PClientToRouter::release_quality_e2e() {
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::CMsgSteamDatagramConnectionQuality* temp = _impl_.quality_e2e_;
  _impl_.quality_e2e_ = 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 ::CMsgSteamDatagramConnectionQuality* CMsgSteamDatagramConnectionStatsP2PClientToRouter::unsafe_arena_release_quality_e2e() {
  // @@protoc_insertion_point(field_release:CMsgSteamDatagramConnectionStatsP2PClientToRouter.quality_e2e)
  _impl_._has_bits_[0] &= ~0x00000008u;
  ::CMsgSteamDatagramConnectionQuality* temp = _impl_.quality_e2e_;
  _impl_.quality_e2e_ = nullptr;
  return temp;
}
inline ::CMsgSteamDatagramConnectionQuality* CMsgSteamDatagramConnectionStatsP2PClientToRouter::_internal_mutable_quality_e2e() {
  _impl_._has_bits_[0] |= 0x00000008u;
  if (_impl_.quality_e2e_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgSteamDatagramConnectionQuality>(GetArenaForAllocation());
    _impl_.quality_e2e_ = p;
  }
  return _impl_.quality_e2e_;
}
inline ::CMsgSteamDatagramConnectionQuality* CMsgSteamDatagramConnectionStatsP2PClientToRouter::mutable_quality_e2e() {
  ::CMsgSteamDatagramConnectionQuality* _msg = _internal_mutable_quality_e2e();
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramConnectionStatsP2PClientToRouter.quality_e2e)
  return _msg;
}
inline void CMsgSteamDatagramConnectionStatsP2PClientToRouter::set_allocated_quality_e2e(::CMsgSteamDatagramConnectionQuality* quality_e2e) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.quality_e2e_);
  }
  if (quality_e2e) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(quality_e2e));
    if (message_arena != submessage_arena) {
      quality_e2e = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, quality_e2e, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000008u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000008u;
  }
  _impl_.quality_e2e_ = quality_e2e;
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamDatagramConnectionStatsP2PClientToRouter.quality_e2e)
}

// optional .CMsgSteamDatagramP2PRoutingSummary p2p_routing_summary = 14;
inline bool CMsgSteamDatagramConnectionStatsP2PClientToRouter::_internal_has_p2p_routing_summary() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.p2p_routing_summary_ != nullptr);
  return value;
}
inline bool CMsgSteamDatagramConnectionStatsP2PClientToRouter::has_p2p_routing_summary() const {
  return _internal_has_p2p_routing_summary();
}
inline void CMsgSteamDatagramConnectionStatsP2PClientToRouter::clear_p2p_routing_summary() {
  if (_impl_.p2p_routing_summary_ != nullptr) _impl_.p2p_routing_summary_->Clear();
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline const ::CMsgSteamDatagramP2PRoutingSummary& CMsgSteamDatagramConnectionStatsP2PClientToRouter::_internal_p2p_routing_summary() const {
  const ::CMsgSteamDatagramP2PRoutingSummary* p = _impl_.p2p_routing_summary_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgSteamDatagramP2PRoutingSummary&>(
      ::_CMsgSteamDatagramP2PRoutingSummary_default_instance_);
}
inline const ::CMsgSteamDatagramP2PRoutingSummary& CMsgSteamDatagramConnectionStatsP2PClientToRouter::p2p_routing_summary() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectionStatsP2PClientToRouter.p2p_routing_summary)
  return _internal_p2p_routing_summary();
}
inline void CMsgSteamDatagramConnectionStatsP2PClientToRouter::unsafe_arena_set_allocated_p2p_routing_summary(
    ::CMsgSteamDatagramP2PRoutingSummary* p2p_routing_summary) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.p2p_routing_summary_);
  }
  _impl_.p2p_routing_summary_ = p2p_routing_summary;
  if (p2p_routing_summary) {
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgSteamDatagramConnectionStatsP2PClientToRouter.p2p_routing_summary)
}
inline ::CMsgSteamDatagramP2PRoutingSummary* CMsgSteamDatagramConnectionStatsP2PClientToRouter::release_p2p_routing_summary() {
  _impl_._has_bits_[0] &= ~0x00000010u;
  ::CMsgSteamDatagramP2PRoutingSummary* temp = _impl_.p2p_routing_summary_;
  _impl_.p2p_routing_summary_ = 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 ::CMsgSteamDatagramP2PRoutingSummary* CMsgSteamDatagramConnectionStatsP2PClientToRouter::unsafe_arena_release_p2p_routing_summary() {
  // @@protoc_insertion_point(field_release:CMsgSteamDatagramConnectionStatsP2PClientToRouter.p2p_routing_summary)
  _impl_._has_bits_[0] &= ~0x00000010u;
  ::CMsgSteamDatagramP2PRoutingSummary* temp = _impl_.p2p_routing_summary_;
  _impl_.p2p_routing_summary_ = nullptr;
  return temp;
}
inline ::CMsgSteamDatagramP2PRoutingSummary* CMsgSteamDatagramConnectionStatsP2PClientToRouter::_internal_mutable_p2p_routing_summary() {
  _impl_._has_bits_[0] |= 0x00000010u;
  if (_impl_.p2p_routing_summary_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgSteamDatagramP2PRoutingSummary>(GetArenaForAllocation());
    _impl_.p2p_routing_summary_ = p;
  }
  return _impl_.p2p_routing_summary_;
}
inline ::CMsgSteamDatagramP2PRoutingSummary* CMsgSteamDatagramConnectionStatsP2PClientToRouter::mutable_p2p_routing_summary() {
  ::CMsgSteamDatagramP2PRoutingSummary* _msg = _internal_mutable_p2p_routing_summary();
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramConnectionStatsP2PClientToRouter.p2p_routing_summary)
  return _msg;
}
inline void CMsgSteamDatagramConnectionStatsP2PClientToRouter::set_allocated_p2p_routing_summary(::CMsgSteamDatagramP2PRoutingSummary* p2p_routing_summary) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete _impl_.p2p_routing_summary_;
  }
  if (p2p_routing_summary) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(p2p_routing_summary);
    if (message_arena != submessage_arena) {
      p2p_routing_summary = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, p2p_routing_summary, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000010u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000010u;
  }
  _impl_.p2p_routing_summary_ = p2p_routing_summary;
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamDatagramConnectionStatsP2PClientToRouter.p2p_routing_summary)
}

// repeated fixed32 ack_relay = 3;
inline int CMsgSteamDatagramConnectionStatsP2PClientToRouter::_internal_ack_relay_size() const {
  return _impl_.ack_relay_.size();
}
inline int CMsgSteamDatagramConnectionStatsP2PClientToRouter::ack_relay_size() const {
  return _internal_ack_relay_size();
}
inline void CMsgSteamDatagramConnectionStatsP2PClientToRouter::clear_ack_relay() {
  _impl_.ack_relay_.Clear();
}
inline uint32_t CMsgSteamDatagramConnectionStatsP2PClientToRouter::_internal_ack_relay(int index) const {
  return _impl_.ack_relay_.Get(index);
}
inline uint32_t CMsgSteamDatagramConnectionStatsP2PClientToRouter::ack_relay(int index) const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectionStatsP2PClientToRouter.ack_relay)
  return _internal_ack_relay(index);
}
inline void CMsgSteamDatagramConnectionStatsP2PClientToRouter::set_ack_relay(int index, uint32_t value) {
  _impl_.ack_relay_.Set(index, value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramConnectionStatsP2PClientToRouter.ack_relay)
}
inline void CMsgSteamDatagramConnectionStatsP2PClientToRouter::_internal_add_ack_relay(uint32_t value) {
  _impl_.ack_relay_.Add(value);
}
inline void CMsgSteamDatagramConnectionStatsP2PClientToRouter::add_ack_relay(uint32_t value) {
  _internal_add_ack_relay(value);
  // @@protoc_insertion_point(field_add:CMsgSteamDatagramConnectionStatsP2PClientToRouter.ack_relay)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
CMsgSteamDatagramConnectionStatsP2PClientToRouter::_internal_ack_relay() const {
  return _impl_.ack_relay_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
CMsgSteamDatagramConnectionStatsP2PClientToRouter::ack_relay() const {
  // @@protoc_insertion_point(field_list:CMsgSteamDatagramConnectionStatsP2PClientToRouter.ack_relay)
  return _internal_ack_relay();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
CMsgSteamDatagramConnectionStatsP2PClientToRouter::_internal_mutable_ack_relay() {
  return &_impl_.ack_relay_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
CMsgSteamDatagramConnectionStatsP2PClientToRouter::mutable_ack_relay() {
  // @@protoc_insertion_point(field_mutable_list:CMsgSteamDatagramConnectionStatsP2PClientToRouter.ack_relay)
  return _internal_mutable_ack_relay();
}

// repeated fixed32 legacy_ack_e2e = 4;
inline int CMsgSteamDatagramConnectionStatsP2PClientToRouter::_internal_legacy_ack_e2e_size() const {
  return _impl_.legacy_ack_e2e_.size();
}
inline int CMsgSteamDatagramConnectionStatsP2PClientToRouter::legacy_ack_e2e_size() const {
  return _internal_legacy_ack_e2e_size();
}
inline void CMsgSteamDatagramConnectionStatsP2PClientToRouter::clear_legacy_ack_e2e() {
  _impl_.legacy_ack_e2e_.Clear();
}
inline uint32_t CMsgSteamDatagramConnectionStatsP2PClientToRouter::_internal_legacy_ack_e2e(int index) const {
  return _impl_.legacy_ack_e2e_.Get(index);
}
inline uint32_t CMsgSteamDatagramConnectionStatsP2PClientToRouter::legacy_ack_e2e(int index) const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectionStatsP2PClientToRouter.legacy_ack_e2e)
  return _internal_legacy_ack_e2e(index);
}
inline void CMsgSteamDatagramConnectionStatsP2PClientToRouter::set_legacy_ack_e2e(int index, uint32_t value) {
  _impl_.legacy_ack_e2e_.Set(index, value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramConnectionStatsP2PClientToRouter.legacy_ack_e2e)
}
inline void CMsgSteamDatagramConnectionStatsP2PClientToRouter::_internal_add_legacy_ack_e2e(uint32_t value) {
  _impl_.legacy_ack_e2e_.Add(value);
}
inline void CMsgSteamDatagramConnectionStatsP2PClientToRouter::add_legacy_ack_e2e(uint32_t value) {
  _internal_add_legacy_ack_e2e(value);
  // @@protoc_insertion_point(field_add:CMsgSteamDatagramConnectionStatsP2PClientToRouter.legacy_ack_e2e)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
CMsgSteamDatagramConnectionStatsP2PClientToRouter::_internal_legacy_ack_e2e() const {
  return _impl_.legacy_ack_e2e_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
CMsgSteamDatagramConnectionStatsP2PClientToRouter::legacy_ack_e2e() const {
  // @@protoc_insertion_point(field_list:CMsgSteamDatagramConnectionStatsP2PClientToRouter.legacy_ack_e2e)
  return _internal_legacy_ack_e2e();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
CMsgSteamDatagramConnectionStatsP2PClientToRouter::_internal_mutable_legacy_ack_e2e() {
  return &_impl_.legacy_ack_e2e_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
CMsgSteamDatagramConnectionStatsP2PClientToRouter::mutable_legacy_ack_e2e() {
  // @@protoc_insertion_point(field_mutable_list:CMsgSteamDatagramConnectionStatsP2PClientToRouter.legacy_ack_e2e)
  return _internal_mutable_legacy_ack_e2e();
}

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

// optional bytes forward_target_relay_routing_token = 6;
inline bool CMsgSteamDatagramConnectionStatsP2PClientToRouter::_internal_has_forward_target_relay_routing_token() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgSteamDatagramConnectionStatsP2PClientToRouter::has_forward_target_relay_routing_token() const {
  return _internal_has_forward_target_relay_routing_token();
}
inline void CMsgSteamDatagramConnectionStatsP2PClientToRouter::clear_forward_target_relay_routing_token() {
  _impl_.forward_target_relay_routing_token_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CMsgSteamDatagramConnectionStatsP2PClientToRouter::forward_target_relay_routing_token() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectionStatsP2PClientToRouter.forward_target_relay_routing_token)
  return _internal_forward_target_relay_routing_token();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgSteamDatagramConnectionStatsP2PClientToRouter::set_forward_target_relay_routing_token(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.forward_target_relay_routing_token_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramConnectionStatsP2PClientToRouter.forward_target_relay_routing_token)
}
inline std::string* CMsgSteamDatagramConnectionStatsP2PClientToRouter::mutable_forward_target_relay_routing_token() {
  std::string* _s = _internal_mutable_forward_target_relay_routing_token();
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramConnectionStatsP2PClientToRouter.forward_target_relay_routing_token)
  return _s;
}
inline const std::string& CMsgSteamDatagramConnectionStatsP2PClientToRouter::_internal_forward_target_relay_routing_token() const {
  return _impl_.forward_target_relay_routing_token_.Get();
}
inline void CMsgSteamDatagramConnectionStatsP2PClientToRouter::_internal_set_forward_target_relay_routing_token(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.forward_target_relay_routing_token_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramConnectionStatsP2PClientToRouter::_internal_mutable_forward_target_relay_routing_token() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.forward_target_relay_routing_token_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramConnectionStatsP2PClientToRouter::release_forward_target_relay_routing_token() {
  // @@protoc_insertion_point(field_release:CMsgSteamDatagramConnectionStatsP2PClientToRouter.forward_target_relay_routing_token)
  if (!_internal_has_forward_target_relay_routing_token()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.forward_target_relay_routing_token_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.forward_target_relay_routing_token_.IsDefault()) {
    _impl_.forward_target_relay_routing_token_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgSteamDatagramConnectionStatsP2PClientToRouter::set_allocated_forward_target_relay_routing_token(std::string* forward_target_relay_routing_token) {
  if (forward_target_relay_routing_token != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.forward_target_relay_routing_token_.SetAllocated(forward_target_relay_routing_token, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.forward_target_relay_routing_token_.IsDefault()) {
    _impl_.forward_target_relay_routing_token_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamDatagramConnectionStatsP2PClientToRouter.forward_target_relay_routing_token)
}

// optional uint32 forward_target_revision = 7;
inline bool CMsgSteamDatagramConnectionStatsP2PClientToRouter::_internal_has_forward_target_revision() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool CMsgSteamDatagramConnectionStatsP2PClientToRouter::has_forward_target_revision() const {
  return _internal_has_forward_target_revision();
}
inline void CMsgSteamDatagramConnectionStatsP2PClientToRouter::clear_forward_target_revision() {
  _impl_.forward_target_revision_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline uint32_t CMsgSteamDatagramConnectionStatsP2PClientToRouter::_internal_forward_target_revision() const {
  return _impl_.forward_target_revision_;
}
inline uint32_t CMsgSteamDatagramConnectionStatsP2PClientToRouter::forward_target_revision() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectionStatsP2PClientToRouter.forward_target_revision)
  return _internal_forward_target_revision();
}
inline void CMsgSteamDatagramConnectionStatsP2PClientToRouter::_internal_set_forward_target_revision(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.forward_target_revision_ = value;
}
inline void CMsgSteamDatagramConnectionStatsP2PClientToRouter::set_forward_target_revision(uint32_t value) {
  _internal_set_forward_target_revision(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramConnectionStatsP2PClientToRouter.forward_target_revision)
}

// optional bytes routes = 8;
inline bool CMsgSteamDatagramConnectionStatsP2PClientToRouter::_internal_has_routes() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgSteamDatagramConnectionStatsP2PClientToRouter::has_routes() const {
  return _internal_has_routes();
}
inline void CMsgSteamDatagramConnectionStatsP2PClientToRouter::clear_routes() {
  _impl_.routes_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& CMsgSteamDatagramConnectionStatsP2PClientToRouter::routes() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectionStatsP2PClientToRouter.routes)
  return _internal_routes();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgSteamDatagramConnectionStatsP2PClientToRouter::set_routes(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.routes_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramConnectionStatsP2PClientToRouter.routes)
}
inline std::string* CMsgSteamDatagramConnectionStatsP2PClientToRouter::mutable_routes() {
  std::string* _s = _internal_mutable_routes();
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramConnectionStatsP2PClientToRouter.routes)
  return _s;
}
inline const std::string& CMsgSteamDatagramConnectionStatsP2PClientToRouter::_internal_routes() const {
  return _impl_.routes_.Get();
}
inline void CMsgSteamDatagramConnectionStatsP2PClientToRouter::_internal_set_routes(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.routes_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramConnectionStatsP2PClientToRouter::_internal_mutable_routes() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.routes_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramConnectionStatsP2PClientToRouter::release_routes() {
  // @@protoc_insertion_point(field_release:CMsgSteamDatagramConnectionStatsP2PClientToRouter.routes)
  if (!_internal_has_routes()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.routes_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.routes_.IsDefault()) {
    _impl_.routes_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgSteamDatagramConnectionStatsP2PClientToRouter::set_allocated_routes(std::string* routes) {
  if (routes != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.routes_.SetAllocated(routes, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.routes_.IsDefault()) {
    _impl_.routes_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamDatagramConnectionStatsP2PClientToRouter.routes)
}

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

// optional fixed32 connection_id = 10;
inline bool CMsgSteamDatagramConnectionStatsP2PClientToRouter::_internal_has_connection_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool CMsgSteamDatagramConnectionStatsP2PClientToRouter::has_connection_id() const {
  return _internal_has_connection_id();
}
inline void CMsgSteamDatagramConnectionStatsP2PClientToRouter::clear_connection_id() {
  _impl_.connection_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline uint32_t CMsgSteamDatagramConnectionStatsP2PClientToRouter::_internal_connection_id() const {
  return _impl_.connection_id_;
}
inline uint32_t CMsgSteamDatagramConnectionStatsP2PClientToRouter::connection_id() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectionStatsP2PClientToRouter.connection_id)
  return _internal_connection_id();
}
inline void CMsgSteamDatagramConnectionStatsP2PClientToRouter::_internal_set_connection_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.connection_id_ = value;
}
inline void CMsgSteamDatagramConnectionStatsP2PClientToRouter::set_connection_id(uint32_t value) {
  _internal_set_connection_id(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramConnectionStatsP2PClientToRouter.connection_id)
}

// optional uint32 seq_num_c2r = 11;
inline bool CMsgSteamDatagramConnectionStatsP2PClientToRouter::_internal_has_seq_num_c2r() const {
  bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool CMsgSteamDatagramConnectionStatsP2PClientToRouter::has_seq_num_c2r() const {
  return _internal_has_seq_num_c2r();
}
inline void CMsgSteamDatagramConnectionStatsP2PClientToRouter::clear_seq_num_c2r() {
  _impl_.seq_num_c2r_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000200u;
}
inline uint32_t CMsgSteamDatagramConnectionStatsP2PClientToRouter::_internal_seq_num_c2r() const {
  return _impl_.seq_num_c2r_;
}
inline uint32_t CMsgSteamDatagramConnectionStatsP2PClientToRouter::seq_num_c2r() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectionStatsP2PClientToRouter.seq_num_c2r)
  return _internal_seq_num_c2r();
}
inline void CMsgSteamDatagramConnectionStatsP2PClientToRouter::_internal_set_seq_num_c2r(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000200u;
  _impl_.seq_num_c2r_ = value;
}
inline void CMsgSteamDatagramConnectionStatsP2PClientToRouter::set_seq_num_c2r(uint32_t value) {
  _internal_set_seq_num_c2r(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramConnectionStatsP2PClientToRouter.seq_num_c2r)
}

// optional uint32 seq_num_e2e = 12;
inline bool CMsgSteamDatagramConnectionStatsP2PClientToRouter::_internal_has_seq_num_e2e() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool CMsgSteamDatagramConnectionStatsP2PClientToRouter::has_seq_num_e2e() const {
  return _internal_has_seq_num_e2e();
}
inline void CMsgSteamDatagramConnectionStatsP2PClientToRouter::clear_seq_num_e2e() {
  _impl_.seq_num_e2e_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline uint32_t CMsgSteamDatagramConnectionStatsP2PClientToRouter::_internal_seq_num_e2e() const {
  return _impl_.seq_num_e2e_;
}
inline uint32_t CMsgSteamDatagramConnectionStatsP2PClientToRouter::seq_num_e2e() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectionStatsP2PClientToRouter.seq_num_e2e)
  return _internal_seq_num_e2e();
}
inline void CMsgSteamDatagramConnectionStatsP2PClientToRouter::_internal_set_seq_num_e2e(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000400u;
  _impl_.seq_num_e2e_ = value;
}
inline void CMsgSteamDatagramConnectionStatsP2PClientToRouter::set_seq_num_e2e(uint32_t value) {
  _internal_set_seq_num_e2e(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramConnectionStatsP2PClientToRouter.seq_num_e2e)
}

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

// CMsgSteamDatagramConnectionStatsP2PRouterToClient

// optional .CMsgSteamDatagramConnectionQuality quality_relay = 1;
inline bool CMsgSteamDatagramConnectionStatsP2PRouterToClient::_internal_has_quality_relay() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.quality_relay_ != nullptr);
  return value;
}
inline bool CMsgSteamDatagramConnectionStatsP2PRouterToClient::has_quality_relay() const {
  return _internal_has_quality_relay();
}
inline const ::CMsgSteamDatagramConnectionQuality& CMsgSteamDatagramConnectionStatsP2PRouterToClient::_internal_quality_relay() const {
  const ::CMsgSteamDatagramConnectionQuality* p = _impl_.quality_relay_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgSteamDatagramConnectionQuality&>(
      ::_CMsgSteamDatagramConnectionQuality_default_instance_);
}
inline const ::CMsgSteamDatagramConnectionQuality& CMsgSteamDatagramConnectionStatsP2PRouterToClient::quality_relay() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectionStatsP2PRouterToClient.quality_relay)
  return _internal_quality_relay();
}
inline void CMsgSteamDatagramConnectionStatsP2PRouterToClient::unsafe_arena_set_allocated_quality_relay(
    ::CMsgSteamDatagramConnectionQuality* quality_relay) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.quality_relay_);
  }
  _impl_.quality_relay_ = quality_relay;
  if (quality_relay) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgSteamDatagramConnectionStatsP2PRouterToClient.quality_relay)
}
inline ::CMsgSteamDatagramConnectionQuality* CMsgSteamDatagramConnectionStatsP2PRouterToClient::release_quality_relay() {
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgSteamDatagramConnectionQuality* temp = _impl_.quality_relay_;
  _impl_.quality_relay_ = 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 ::CMsgSteamDatagramConnectionQuality* CMsgSteamDatagramConnectionStatsP2PRouterToClient::unsafe_arena_release_quality_relay() {
  // @@protoc_insertion_point(field_release:CMsgSteamDatagramConnectionStatsP2PRouterToClient.quality_relay)
  _impl_._has_bits_[0] &= ~0x00000002u;
  ::CMsgSteamDatagramConnectionQuality* temp = _impl_.quality_relay_;
  _impl_.quality_relay_ = nullptr;
  return temp;
}
inline ::CMsgSteamDatagramConnectionQuality* CMsgSteamDatagramConnectionStatsP2PRouterToClient::_internal_mutable_quality_relay() {
  _impl_._has_bits_[0] |= 0x00000002u;
  if (_impl_.quality_relay_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgSteamDatagramConnectionQuality>(GetArenaForAllocation());
    _impl_.quality_relay_ = p;
  }
  return _impl_.quality_relay_;
}
inline ::CMsgSteamDatagramConnectionQuality* CMsgSteamDatagramConnectionStatsP2PRouterToClient::mutable_quality_relay() {
  ::CMsgSteamDatagramConnectionQuality* _msg = _internal_mutable_quality_relay();
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramConnectionStatsP2PRouterToClient.quality_relay)
  return _msg;
}
inline void CMsgSteamDatagramConnectionStatsP2PRouterToClient::set_allocated_quality_relay(::CMsgSteamDatagramConnectionQuality* quality_relay) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.quality_relay_);
  }
  if (quality_relay) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(quality_relay));
    if (message_arena != submessage_arena) {
      quality_relay = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, quality_relay, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.quality_relay_ = quality_relay;
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamDatagramConnectionStatsP2PRouterToClient.quality_relay)
}

// optional .CMsgSteamDatagramConnectionQuality quality_e2e = 2;
inline bool CMsgSteamDatagramConnectionStatsP2PRouterToClient::_internal_has_quality_e2e() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  PROTOBUF_ASSUME(!value || _impl_.quality_e2e_ != nullptr);
  return value;
}
inline bool CMsgSteamDatagramConnectionStatsP2PRouterToClient::has_quality_e2e() const {
  return _internal_has_quality_e2e();
}
inline const ::CMsgSteamDatagramConnectionQuality& CMsgSteamDatagramConnectionStatsP2PRouterToClient::_internal_quality_e2e() const {
  const ::CMsgSteamDatagramConnectionQuality* p = _impl_.quality_e2e_;
  return p != nullptr ? *p : reinterpret_cast<const ::CMsgSteamDatagramConnectionQuality&>(
      ::_CMsgSteamDatagramConnectionQuality_default_instance_);
}
inline const ::CMsgSteamDatagramConnectionQuality& CMsgSteamDatagramConnectionStatsP2PRouterToClient::quality_e2e() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectionStatsP2PRouterToClient.quality_e2e)
  return _internal_quality_e2e();
}
inline void CMsgSteamDatagramConnectionStatsP2PRouterToClient::unsafe_arena_set_allocated_quality_e2e(
    ::CMsgSteamDatagramConnectionQuality* quality_e2e) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.quality_e2e_);
  }
  _impl_.quality_e2e_ = quality_e2e;
  if (quality_e2e) {
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:CMsgSteamDatagramConnectionStatsP2PRouterToClient.quality_e2e)
}
inline ::CMsgSteamDatagramConnectionQuality* CMsgSteamDatagramConnectionStatsP2PRouterToClient::release_quality_e2e() {
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::CMsgSteamDatagramConnectionQuality* temp = _impl_.quality_e2e_;
  _impl_.quality_e2e_ = 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 ::CMsgSteamDatagramConnectionQuality* CMsgSteamDatagramConnectionStatsP2PRouterToClient::unsafe_arena_release_quality_e2e() {
  // @@protoc_insertion_point(field_release:CMsgSteamDatagramConnectionStatsP2PRouterToClient.quality_e2e)
  _impl_._has_bits_[0] &= ~0x00000004u;
  ::CMsgSteamDatagramConnectionQuality* temp = _impl_.quality_e2e_;
  _impl_.quality_e2e_ = nullptr;
  return temp;
}
inline ::CMsgSteamDatagramConnectionQuality* CMsgSteamDatagramConnectionStatsP2PRouterToClient::_internal_mutable_quality_e2e() {
  _impl_._has_bits_[0] |= 0x00000004u;
  if (_impl_.quality_e2e_ == nullptr) {
    auto* p = CreateMaybeMessage<::CMsgSteamDatagramConnectionQuality>(GetArenaForAllocation());
    _impl_.quality_e2e_ = p;
  }
  return _impl_.quality_e2e_;
}
inline ::CMsgSteamDatagramConnectionQuality* CMsgSteamDatagramConnectionStatsP2PRouterToClient::mutable_quality_e2e() {
  ::CMsgSteamDatagramConnectionQuality* _msg = _internal_mutable_quality_e2e();
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramConnectionStatsP2PRouterToClient.quality_e2e)
  return _msg;
}
inline void CMsgSteamDatagramConnectionStatsP2PRouterToClient::set_allocated_quality_e2e(::CMsgSteamDatagramConnectionQuality* quality_e2e) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.quality_e2e_);
  }
  if (quality_e2e) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(quality_e2e));
    if (message_arena != submessage_arena) {
      quality_e2e = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, quality_e2e, submessage_arena);
    }
    _impl_._has_bits_[0] |= 0x00000004u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000004u;
  }
  _impl_.quality_e2e_ = quality_e2e;
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamDatagramConnectionStatsP2PRouterToClient.quality_e2e)
}

// optional uint32 seconds_until_shutdown = 3;
inline bool CMsgSteamDatagramConnectionStatsP2PRouterToClient::_internal_has_seconds_until_shutdown() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CMsgSteamDatagramConnectionStatsP2PRouterToClient::has_seconds_until_shutdown() const {
  return _internal_has_seconds_until_shutdown();
}
inline void CMsgSteamDatagramConnectionStatsP2PRouterToClient::clear_seconds_until_shutdown() {
  _impl_.seconds_until_shutdown_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t CMsgSteamDatagramConnectionStatsP2PRouterToClient::_internal_seconds_until_shutdown() const {
  return _impl_.seconds_until_shutdown_;
}
inline uint32_t CMsgSteamDatagramConnectionStatsP2PRouterToClient::seconds_until_shutdown() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectionStatsP2PRouterToClient.seconds_until_shutdown)
  return _internal_seconds_until_shutdown();
}
inline void CMsgSteamDatagramConnectionStatsP2PRouterToClient::_internal_set_seconds_until_shutdown(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.seconds_until_shutdown_ = value;
}
inline void CMsgSteamDatagramConnectionStatsP2PRouterToClient::set_seconds_until_shutdown(uint32_t value) {
  _internal_set_seconds_until_shutdown(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramConnectionStatsP2PRouterToClient.seconds_until_shutdown)
}

// optional fixed32 migrate_request_ip = 4;
inline bool CMsgSteamDatagramConnectionStatsP2PRouterToClient::_internal_has_migrate_request_ip() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CMsgSteamDatagramConnectionStatsP2PRouterToClient::has_migrate_request_ip() const {
  return _internal_has_migrate_request_ip();
}
inline void CMsgSteamDatagramConnectionStatsP2PRouterToClient::clear_migrate_request_ip() {
  _impl_.migrate_request_ip_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline uint32_t CMsgSteamDatagramConnectionStatsP2PRouterToClient::_internal_migrate_request_ip() const {
  return _impl_.migrate_request_ip_;
}
inline uint32_t CMsgSteamDatagramConnectionStatsP2PRouterToClient::migrate_request_ip() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectionStatsP2PRouterToClient.migrate_request_ip)
  return _internal_migrate_request_ip();
}
inline void CMsgSteamDatagramConnectionStatsP2PRouterToClient::_internal_set_migrate_request_ip(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.migrate_request_ip_ = value;
}
inline void CMsgSteamDatagramConnectionStatsP2PRouterToClient::set_migrate_request_ip(uint32_t value) {
  _internal_set_migrate_request_ip(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramConnectionStatsP2PRouterToClient.migrate_request_ip)
}

// optional uint32 migrate_request_port = 5;
inline bool CMsgSteamDatagramConnectionStatsP2PRouterToClient::_internal_has_migrate_request_port() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool CMsgSteamDatagramConnectionStatsP2PRouterToClient::has_migrate_request_port() const {
  return _internal_has_migrate_request_port();
}
inline void CMsgSteamDatagramConnectionStatsP2PRouterToClient::clear_migrate_request_port() {
  _impl_.migrate_request_port_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline uint32_t CMsgSteamDatagramConnectionStatsP2PRouterToClient::_internal_migrate_request_port() const {
  return _impl_.migrate_request_port_;
}
inline uint32_t CMsgSteamDatagramConnectionStatsP2PRouterToClient::migrate_request_port() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectionStatsP2PRouterToClient.migrate_request_port)
  return _internal_migrate_request_port();
}
inline void CMsgSteamDatagramConnectionStatsP2PRouterToClient::_internal_set_migrate_request_port(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.migrate_request_port_ = value;
}
inline void CMsgSteamDatagramConnectionStatsP2PRouterToClient::set_migrate_request_port(uint32_t value) {
  _internal_set_migrate_request_port(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramConnectionStatsP2PRouterToClient.migrate_request_port)
}

// optional uint32 scoring_penalty_relay_cluster = 6;
inline bool CMsgSteamDatagramConnectionStatsP2PRouterToClient::_internal_has_scoring_penalty_relay_cluster() const {
  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool CMsgSteamDatagramConnectionStatsP2PRouterToClient::has_scoring_penalty_relay_cluster() const {
  return _internal_has_scoring_penalty_relay_cluster();
}
inline void CMsgSteamDatagramConnectionStatsP2PRouterToClient::clear_scoring_penalty_relay_cluster() {
  _impl_.scoring_penalty_relay_cluster_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000040u;
}
inline uint32_t CMsgSteamDatagramConnectionStatsP2PRouterToClient::_internal_scoring_penalty_relay_cluster() const {
  return _impl_.scoring_penalty_relay_cluster_;
}
inline uint32_t CMsgSteamDatagramConnectionStatsP2PRouterToClient::scoring_penalty_relay_cluster() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectionStatsP2PRouterToClient.scoring_penalty_relay_cluster)
  return _internal_scoring_penalty_relay_cluster();
}
inline void CMsgSteamDatagramConnectionStatsP2PRouterToClient::_internal_set_scoring_penalty_relay_cluster(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000040u;
  _impl_.scoring_penalty_relay_cluster_ = value;
}
inline void CMsgSteamDatagramConnectionStatsP2PRouterToClient::set_scoring_penalty_relay_cluster(uint32_t value) {
  _internal_set_scoring_penalty_relay_cluster(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramConnectionStatsP2PRouterToClient.scoring_penalty_relay_cluster)
}

// repeated fixed32 ack_relay = 7;
inline int CMsgSteamDatagramConnectionStatsP2PRouterToClient::_internal_ack_relay_size() const {
  return _impl_.ack_relay_.size();
}
inline int CMsgSteamDatagramConnectionStatsP2PRouterToClient::ack_relay_size() const {
  return _internal_ack_relay_size();
}
inline void CMsgSteamDatagramConnectionStatsP2PRouterToClient::clear_ack_relay() {
  _impl_.ack_relay_.Clear();
}
inline uint32_t CMsgSteamDatagramConnectionStatsP2PRouterToClient::_internal_ack_relay(int index) const {
  return _impl_.ack_relay_.Get(index);
}
inline uint32_t CMsgSteamDatagramConnectionStatsP2PRouterToClient::ack_relay(int index) const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectionStatsP2PRouterToClient.ack_relay)
  return _internal_ack_relay(index);
}
inline void CMsgSteamDatagramConnectionStatsP2PRouterToClient::set_ack_relay(int index, uint32_t value) {
  _impl_.ack_relay_.Set(index, value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramConnectionStatsP2PRouterToClient.ack_relay)
}
inline void CMsgSteamDatagramConnectionStatsP2PRouterToClient::_internal_add_ack_relay(uint32_t value) {
  _impl_.ack_relay_.Add(value);
}
inline void CMsgSteamDatagramConnectionStatsP2PRouterToClient::add_ack_relay(uint32_t value) {
  _internal_add_ack_relay(value);
  // @@protoc_insertion_point(field_add:CMsgSteamDatagramConnectionStatsP2PRouterToClient.ack_relay)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
CMsgSteamDatagramConnectionStatsP2PRouterToClient::_internal_ack_relay() const {
  return _impl_.ack_relay_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
CMsgSteamDatagramConnectionStatsP2PRouterToClient::ack_relay() const {
  // @@protoc_insertion_point(field_list:CMsgSteamDatagramConnectionStatsP2PRouterToClient.ack_relay)
  return _internal_ack_relay();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
CMsgSteamDatagramConnectionStatsP2PRouterToClient::_internal_mutable_ack_relay() {
  return &_impl_.ack_relay_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
CMsgSteamDatagramConnectionStatsP2PRouterToClient::mutable_ack_relay() {
  // @@protoc_insertion_point(field_mutable_list:CMsgSteamDatagramConnectionStatsP2PRouterToClient.ack_relay)
  return _internal_mutable_ack_relay();
}

// repeated fixed32 legacy_ack_e2e = 8;
inline int CMsgSteamDatagramConnectionStatsP2PRouterToClient::_internal_legacy_ack_e2e_size() const {
  return _impl_.legacy_ack_e2e_.size();
}
inline int CMsgSteamDatagramConnectionStatsP2PRouterToClient::legacy_ack_e2e_size() const {
  return _internal_legacy_ack_e2e_size();
}
inline void CMsgSteamDatagramConnectionStatsP2PRouterToClient::clear_legacy_ack_e2e() {
  _impl_.legacy_ack_e2e_.Clear();
}
inline uint32_t CMsgSteamDatagramConnectionStatsP2PRouterToClient::_internal_legacy_ack_e2e(int index) const {
  return _impl_.legacy_ack_e2e_.Get(index);
}
inline uint32_t CMsgSteamDatagramConnectionStatsP2PRouterToClient::legacy_ack_e2e(int index) const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectionStatsP2PRouterToClient.legacy_ack_e2e)
  return _internal_legacy_ack_e2e(index);
}
inline void CMsgSteamDatagramConnectionStatsP2PRouterToClient::set_legacy_ack_e2e(int index, uint32_t value) {
  _impl_.legacy_ack_e2e_.Set(index, value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramConnectionStatsP2PRouterToClient.legacy_ack_e2e)
}
inline void CMsgSteamDatagramConnectionStatsP2PRouterToClient::_internal_add_legacy_ack_e2e(uint32_t value) {
  _impl_.legacy_ack_e2e_.Add(value);
}
inline void CMsgSteamDatagramConnectionStatsP2PRouterToClient::add_legacy_ack_e2e(uint32_t value) {
  _internal_add_legacy_ack_e2e(value);
  // @@protoc_insertion_point(field_add:CMsgSteamDatagramConnectionStatsP2PRouterToClient.legacy_ack_e2e)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
CMsgSteamDatagramConnectionStatsP2PRouterToClient::_internal_legacy_ack_e2e() const {
  return _impl_.legacy_ack_e2e_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
CMsgSteamDatagramConnectionStatsP2PRouterToClient::legacy_ack_e2e() const {
  // @@protoc_insertion_point(field_list:CMsgSteamDatagramConnectionStatsP2PRouterToClient.legacy_ack_e2e)
  return _internal_legacy_ack_e2e();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
CMsgSteamDatagramConnectionStatsP2PRouterToClient::_internal_mutable_legacy_ack_e2e() {
  return &_impl_.legacy_ack_e2e_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
CMsgSteamDatagramConnectionStatsP2PRouterToClient::mutable_legacy_ack_e2e() {
  // @@protoc_insertion_point(field_mutable_list:CMsgSteamDatagramConnectionStatsP2PRouterToClient.legacy_ack_e2e)
  return _internal_mutable_legacy_ack_e2e();
}

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

// optional uint32 ack_forward_target_revision = 10;
inline bool CMsgSteamDatagramConnectionStatsP2PRouterToClient::_internal_has_ack_forward_target_revision() const {
  bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool CMsgSteamDatagramConnectionStatsP2PRouterToClient::has_ack_forward_target_revision() const {
  return _internal_has_ack_forward_target_revision();
}
inline void CMsgSteamDatagramConnectionStatsP2PRouterToClient::clear_ack_forward_target_revision() {
  _impl_.ack_forward_target_revision_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000100u;
}
inline uint32_t CMsgSteamDatagramConnectionStatsP2PRouterToClient::_internal_ack_forward_target_revision() const {
  return _impl_.ack_forward_target_revision_;
}
inline uint32_t CMsgSteamDatagramConnectionStatsP2PRouterToClient::ack_forward_target_revision() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectionStatsP2PRouterToClient.ack_forward_target_revision)
  return _internal_ack_forward_target_revision();
}
inline void CMsgSteamDatagramConnectionStatsP2PRouterToClient::_internal_set_ack_forward_target_revision(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000100u;
  _impl_.ack_forward_target_revision_ = value;
}
inline void CMsgSteamDatagramConnectionStatsP2PRouterToClient::set_ack_forward_target_revision(uint32_t value) {
  _internal_set_ack_forward_target_revision(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramConnectionStatsP2PRouterToClient.ack_forward_target_revision)
}

// optional bytes routes = 11;
inline bool CMsgSteamDatagramConnectionStatsP2PRouterToClient::_internal_has_routes() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgSteamDatagramConnectionStatsP2PRouterToClient::has_routes() const {
  return _internal_has_routes();
}
inline void CMsgSteamDatagramConnectionStatsP2PRouterToClient::clear_routes() {
  _impl_.routes_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CMsgSteamDatagramConnectionStatsP2PRouterToClient::routes() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectionStatsP2PRouterToClient.routes)
  return _internal_routes();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgSteamDatagramConnectionStatsP2PRouterToClient::set_routes(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.routes_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramConnectionStatsP2PRouterToClient.routes)
}
inline std::string* CMsgSteamDatagramConnectionStatsP2PRouterToClient::mutable_routes() {
  std::string* _s = _internal_mutable_routes();
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramConnectionStatsP2PRouterToClient.routes)
  return _s;
}
inline const std::string& CMsgSteamDatagramConnectionStatsP2PRouterToClient::_internal_routes() const {
  return _impl_.routes_.Get();
}
inline void CMsgSteamDatagramConnectionStatsP2PRouterToClient::_internal_set_routes(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.routes_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramConnectionStatsP2PRouterToClient::_internal_mutable_routes() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.routes_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramConnectionStatsP2PRouterToClient::release_routes() {
  // @@protoc_insertion_point(field_release:CMsgSteamDatagramConnectionStatsP2PRouterToClient.routes)
  if (!_internal_has_routes()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.routes_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.routes_.IsDefault()) {
    _impl_.routes_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgSteamDatagramConnectionStatsP2PRouterToClient::set_allocated_routes(std::string* routes) {
  if (routes != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.routes_.SetAllocated(routes, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.routes_.IsDefault()) {
    _impl_.routes_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamDatagramConnectionStatsP2PRouterToClient.routes)
}

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

// optional fixed32 connection_id = 13;
inline bool CMsgSteamDatagramConnectionStatsP2PRouterToClient::_internal_has_connection_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool CMsgSteamDatagramConnectionStatsP2PRouterToClient::has_connection_id() const {
  return _internal_has_connection_id();
}
inline void CMsgSteamDatagramConnectionStatsP2PRouterToClient::clear_connection_id() {
  _impl_.connection_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000400u;
}
inline uint32_t CMsgSteamDatagramConnectionStatsP2PRouterToClient::_internal_connection_id() const {
  return _impl_.connection_id_;
}
inline uint32_t CMsgSteamDatagramConnectionStatsP2PRouterToClient::connection_id() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectionStatsP2PRouterToClient.connection_id)
  return _internal_connection_id();
}
inline void CMsgSteamDatagramConnectionStatsP2PRouterToClient::_internal_set_connection_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000400u;
  _impl_.connection_id_ = value;
}
inline void CMsgSteamDatagramConnectionStatsP2PRouterToClient::set_connection_id(uint32_t value) {
  _internal_set_connection_id(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramConnectionStatsP2PRouterToClient.connection_id)
}

// optional uint32 seq_num_r2c = 14;
inline bool CMsgSteamDatagramConnectionStatsP2PRouterToClient::_internal_has_seq_num_r2c() const {
  bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
  return value;
}
inline bool CMsgSteamDatagramConnectionStatsP2PRouterToClient::has_seq_num_r2c() const {
  return _internal_has_seq_num_r2c();
}
inline void CMsgSteamDatagramConnectionStatsP2PRouterToClient::clear_seq_num_r2c() {
  _impl_.seq_num_r2c_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000800u;
}
inline uint32_t CMsgSteamDatagramConnectionStatsP2PRouterToClient::_internal_seq_num_r2c() const {
  return _impl_.seq_num_r2c_;
}
inline uint32_t CMsgSteamDatagramConnectionStatsP2PRouterToClient::seq_num_r2c() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectionStatsP2PRouterToClient.seq_num_r2c)
  return _internal_seq_num_r2c();
}
inline void CMsgSteamDatagramConnectionStatsP2PRouterToClient::_internal_set_seq_num_r2c(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000800u;
  _impl_.seq_num_r2c_ = value;
}
inline void CMsgSteamDatagramConnectionStatsP2PRouterToClient::set_seq_num_r2c(uint32_t value) {
  _internal_set_seq_num_r2c(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramConnectionStatsP2PRouterToClient.seq_num_r2c)
}

// optional uint32 seq_num_e2e = 15;
inline bool CMsgSteamDatagramConnectionStatsP2PRouterToClient::_internal_has_seq_num_e2e() const {
  bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
  return value;
}
inline bool CMsgSteamDatagramConnectionStatsP2PRouterToClient::has_seq_num_e2e() const {
  return _internal_has_seq_num_e2e();
}
inline void CMsgSteamDatagramConnectionStatsP2PRouterToClient::clear_seq_num_e2e() {
  _impl_.seq_num_e2e_ = 0u;
  _impl_._has_bits_[0] &= ~0x00001000u;
}
inline uint32_t CMsgSteamDatagramConnectionStatsP2PRouterToClient::_internal_seq_num_e2e() const {
  return _impl_.seq_num_e2e_;
}
inline uint32_t CMsgSteamDatagramConnectionStatsP2PRouterToClient::seq_num_e2e() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramConnectionStatsP2PRouterToClient.seq_num_e2e)
  return _internal_seq_num_e2e();
}
inline void CMsgSteamDatagramConnectionStatsP2PRouterToClient::_internal_set_seq_num_e2e(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00001000u;
  _impl_.seq_num_e2e_ = value;
}
inline void CMsgSteamDatagramConnectionStatsP2PRouterToClient::set_seq_num_e2e(uint32_t value) {
  _internal_set_seq_num_e2e(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramConnectionStatsP2PRouterToClient.seq_num_e2e)
}

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

// CMsgSteamDatagramP2PBadRouteRouterToClient

// optional fixed32 connection_id = 1;
inline bool CMsgSteamDatagramP2PBadRouteRouterToClient::_internal_has_connection_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgSteamDatagramP2PBadRouteRouterToClient::has_connection_id() const {
  return _internal_has_connection_id();
}
inline void CMsgSteamDatagramP2PBadRouteRouterToClient::clear_connection_id() {
  _impl_.connection_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t CMsgSteamDatagramP2PBadRouteRouterToClient::_internal_connection_id() const {
  return _impl_.connection_id_;
}
inline uint32_t CMsgSteamDatagramP2PBadRouteRouterToClient::connection_id() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramP2PBadRouteRouterToClient.connection_id)
  return _internal_connection_id();
}
inline void CMsgSteamDatagramP2PBadRouteRouterToClient::_internal_set_connection_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.connection_id_ = value;
}
inline void CMsgSteamDatagramP2PBadRouteRouterToClient::set_connection_id(uint32_t value) {
  _internal_set_connection_id(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramP2PBadRouteRouterToClient.connection_id)
}

// optional bytes failed_relay_routing_token = 2;
inline bool CMsgSteamDatagramP2PBadRouteRouterToClient::_internal_has_failed_relay_routing_token() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgSteamDatagramP2PBadRouteRouterToClient::has_failed_relay_routing_token() const {
  return _internal_has_failed_relay_routing_token();
}
inline void CMsgSteamDatagramP2PBadRouteRouterToClient::clear_failed_relay_routing_token() {
  _impl_.failed_relay_routing_token_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CMsgSteamDatagramP2PBadRouteRouterToClient::failed_relay_routing_token() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramP2PBadRouteRouterToClient.failed_relay_routing_token)
  return _internal_failed_relay_routing_token();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgSteamDatagramP2PBadRouteRouterToClient::set_failed_relay_routing_token(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.failed_relay_routing_token_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramP2PBadRouteRouterToClient.failed_relay_routing_token)
}
inline std::string* CMsgSteamDatagramP2PBadRouteRouterToClient::mutable_failed_relay_routing_token() {
  std::string* _s = _internal_mutable_failed_relay_routing_token();
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramP2PBadRouteRouterToClient.failed_relay_routing_token)
  return _s;
}
inline const std::string& CMsgSteamDatagramP2PBadRouteRouterToClient::_internal_failed_relay_routing_token() const {
  return _impl_.failed_relay_routing_token_.Get();
}
inline void CMsgSteamDatagramP2PBadRouteRouterToClient::_internal_set_failed_relay_routing_token(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.failed_relay_routing_token_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramP2PBadRouteRouterToClient::_internal_mutable_failed_relay_routing_token() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.failed_relay_routing_token_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramP2PBadRouteRouterToClient::release_failed_relay_routing_token() {
  // @@protoc_insertion_point(field_release:CMsgSteamDatagramP2PBadRouteRouterToClient.failed_relay_routing_token)
  if (!_internal_has_failed_relay_routing_token()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.failed_relay_routing_token_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.failed_relay_routing_token_.IsDefault()) {
    _impl_.failed_relay_routing_token_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgSteamDatagramP2PBadRouteRouterToClient::set_allocated_failed_relay_routing_token(std::string* failed_relay_routing_token) {
  if (failed_relay_routing_token != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.failed_relay_routing_token_.SetAllocated(failed_relay_routing_token, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.failed_relay_routing_token_.IsDefault()) {
    _impl_.failed_relay_routing_token_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamDatagramP2PBadRouteRouterToClient.failed_relay_routing_token)
}

// optional uint32 ack_forward_target_revision = 3;
inline bool CMsgSteamDatagramP2PBadRouteRouterToClient::_internal_has_ack_forward_target_revision() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgSteamDatagramP2PBadRouteRouterToClient::has_ack_forward_target_revision() const {
  return _internal_has_ack_forward_target_revision();
}
inline void CMsgSteamDatagramP2PBadRouteRouterToClient::clear_ack_forward_target_revision() {
  _impl_.ack_forward_target_revision_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t CMsgSteamDatagramP2PBadRouteRouterToClient::_internal_ack_forward_target_revision() const {
  return _impl_.ack_forward_target_revision_;
}
inline uint32_t CMsgSteamDatagramP2PBadRouteRouterToClient::ack_forward_target_revision() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramP2PBadRouteRouterToClient.ack_forward_target_revision)
  return _internal_ack_forward_target_revision();
}
inline void CMsgSteamDatagramP2PBadRouteRouterToClient::_internal_set_ack_forward_target_revision(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.ack_forward_target_revision_ = value;
}
inline void CMsgSteamDatagramP2PBadRouteRouterToClient::set_ack_forward_target_revision(uint32_t value) {
  _internal_set_ack_forward_target_revision(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramP2PBadRouteRouterToClient.ack_forward_target_revision)
}

// optional fixed64 kludge_pad = 99;
inline bool CMsgSteamDatagramP2PBadRouteRouterToClient::_internal_has_kludge_pad() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CMsgSteamDatagramP2PBadRouteRouterToClient::has_kludge_pad() const {
  return _internal_has_kludge_pad();
}
inline void CMsgSteamDatagramP2PBadRouteRouterToClient::clear_kludge_pad() {
  _impl_.kludge_pad_ = uint64_t{0u};
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint64_t CMsgSteamDatagramP2PBadRouteRouterToClient::_internal_kludge_pad() const {
  return _impl_.kludge_pad_;
}
inline uint64_t CMsgSteamDatagramP2PBadRouteRouterToClient::kludge_pad() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramP2PBadRouteRouterToClient.kludge_pad)
  return _internal_kludge_pad();
}
inline void CMsgSteamDatagramP2PBadRouteRouterToClient::_internal_set_kludge_pad(uint64_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.kludge_pad_ = value;
}
inline void CMsgSteamDatagramP2PBadRouteRouterToClient::set_kludge_pad(uint64_t value) {
  _internal_set_kludge_pad(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramP2PBadRouteRouterToClient.kludge_pad)
}

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

// CMsgSteamDatagramP2PRoutes_RelayCluster

// optional fixed32 pop_id = 1;
inline bool CMsgSteamDatagramP2PRoutes_RelayCluster::_internal_has_pop_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgSteamDatagramP2PRoutes_RelayCluster::has_pop_id() const {
  return _internal_has_pop_id();
}
inline void CMsgSteamDatagramP2PRoutes_RelayCluster::clear_pop_id() {
  _impl_.pop_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t CMsgSteamDatagramP2PRoutes_RelayCluster::_internal_pop_id() const {
  return _impl_.pop_id_;
}
inline uint32_t CMsgSteamDatagramP2PRoutes_RelayCluster::pop_id() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramP2PRoutes.RelayCluster.pop_id)
  return _internal_pop_id();
}
inline void CMsgSteamDatagramP2PRoutes_RelayCluster::_internal_set_pop_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.pop_id_ = value;
}
inline void CMsgSteamDatagramP2PRoutes_RelayCluster::set_pop_id(uint32_t value) {
  _internal_set_pop_id(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramP2PRoutes.RelayCluster.pop_id)
}

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

// optional uint32 score_penalty = 3;
inline bool CMsgSteamDatagramP2PRoutes_RelayCluster::_internal_has_score_penalty() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CMsgSteamDatagramP2PRoutes_RelayCluster::has_score_penalty() const {
  return _internal_has_score_penalty();
}
inline void CMsgSteamDatagramP2PRoutes_RelayCluster::clear_score_penalty() {
  _impl_.score_penalty_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t CMsgSteamDatagramP2PRoutes_RelayCluster::_internal_score_penalty() const {
  return _impl_.score_penalty_;
}
inline uint32_t CMsgSteamDatagramP2PRoutes_RelayCluster::score_penalty() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramP2PRoutes.RelayCluster.score_penalty)
  return _internal_score_penalty();
}
inline void CMsgSteamDatagramP2PRoutes_RelayCluster::_internal_set_score_penalty(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.score_penalty_ = value;
}
inline void CMsgSteamDatagramP2PRoutes_RelayCluster::set_score_penalty(uint32_t value) {
  _internal_set_score_penalty(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramP2PRoutes.RelayCluster.score_penalty)
}

// optional bytes session_relay_routing_token = 4;
inline bool CMsgSteamDatagramP2PRoutes_RelayCluster::_internal_has_session_relay_routing_token() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgSteamDatagramP2PRoutes_RelayCluster::has_session_relay_routing_token() const {
  return _internal_has_session_relay_routing_token();
}
inline void CMsgSteamDatagramP2PRoutes_RelayCluster::clear_session_relay_routing_token() {
  _impl_.session_relay_routing_token_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CMsgSteamDatagramP2PRoutes_RelayCluster::session_relay_routing_token() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramP2PRoutes.RelayCluster.session_relay_routing_token)
  return _internal_session_relay_routing_token();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgSteamDatagramP2PRoutes_RelayCluster::set_session_relay_routing_token(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.session_relay_routing_token_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramP2PRoutes.RelayCluster.session_relay_routing_token)
}
inline std::string* CMsgSteamDatagramP2PRoutes_RelayCluster::mutable_session_relay_routing_token() {
  std::string* _s = _internal_mutable_session_relay_routing_token();
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramP2PRoutes.RelayCluster.session_relay_routing_token)
  return _s;
}
inline const std::string& CMsgSteamDatagramP2PRoutes_RelayCluster::_internal_session_relay_routing_token() const {
  return _impl_.session_relay_routing_token_.Get();
}
inline void CMsgSteamDatagramP2PRoutes_RelayCluster::_internal_set_session_relay_routing_token(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.session_relay_routing_token_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramP2PRoutes_RelayCluster::_internal_mutable_session_relay_routing_token() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.session_relay_routing_token_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramP2PRoutes_RelayCluster::release_session_relay_routing_token() {
  // @@protoc_insertion_point(field_release:CMsgSteamDatagramP2PRoutes.RelayCluster.session_relay_routing_token)
  if (!_internal_has_session_relay_routing_token()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.session_relay_routing_token_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.session_relay_routing_token_.IsDefault()) {
    _impl_.session_relay_routing_token_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgSteamDatagramP2PRoutes_RelayCluster::set_allocated_session_relay_routing_token(std::string* session_relay_routing_token) {
  if (session_relay_routing_token != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.session_relay_routing_token_.SetAllocated(session_relay_routing_token, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.session_relay_routing_token_.IsDefault()) {
    _impl_.session_relay_routing_token_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamDatagramP2PRoutes.RelayCluster.session_relay_routing_token)
}

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

// CMsgSteamDatagramP2PRoutes_Route

// optional fixed32 my_pop_id = 1;
inline bool CMsgSteamDatagramP2PRoutes_Route::_internal_has_my_pop_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgSteamDatagramP2PRoutes_Route::has_my_pop_id() const {
  return _internal_has_my_pop_id();
}
inline void CMsgSteamDatagramP2PRoutes_Route::clear_my_pop_id() {
  _impl_.my_pop_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t CMsgSteamDatagramP2PRoutes_Route::_internal_my_pop_id() const {
  return _impl_.my_pop_id_;
}
inline uint32_t CMsgSteamDatagramP2PRoutes_Route::my_pop_id() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramP2PRoutes.Route.my_pop_id)
  return _internal_my_pop_id();
}
inline void CMsgSteamDatagramP2PRoutes_Route::_internal_set_my_pop_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.my_pop_id_ = value;
}
inline void CMsgSteamDatagramP2PRoutes_Route::set_my_pop_id(uint32_t value) {
  _internal_set_my_pop_id(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramP2PRoutes.Route.my_pop_id)
}

// optional fixed32 your_pop_id = 2;
inline bool CMsgSteamDatagramP2PRoutes_Route::_internal_has_your_pop_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgSteamDatagramP2PRoutes_Route::has_your_pop_id() const {
  return _internal_has_your_pop_id();
}
inline void CMsgSteamDatagramP2PRoutes_Route::clear_your_pop_id() {
  _impl_.your_pop_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline uint32_t CMsgSteamDatagramP2PRoutes_Route::_internal_your_pop_id() const {
  return _impl_.your_pop_id_;
}
inline uint32_t CMsgSteamDatagramP2PRoutes_Route::your_pop_id() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramP2PRoutes.Route.your_pop_id)
  return _internal_your_pop_id();
}
inline void CMsgSteamDatagramP2PRoutes_Route::_internal_set_your_pop_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.your_pop_id_ = value;
}
inline void CMsgSteamDatagramP2PRoutes_Route::set_your_pop_id(uint32_t value) {
  _internal_set_your_pop_id(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramP2PRoutes.Route.your_pop_id)
}

// optional uint32 legacy_score = 3;
inline bool CMsgSteamDatagramP2PRoutes_Route::_internal_has_legacy_score() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgSteamDatagramP2PRoutes_Route::has_legacy_score() const {
  return _internal_has_legacy_score();
}
inline void CMsgSteamDatagramP2PRoutes_Route::clear_legacy_score() {
  _impl_.legacy_score_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t CMsgSteamDatagramP2PRoutes_Route::_internal_legacy_score() const {
  return _impl_.legacy_score_;
}
inline uint32_t CMsgSteamDatagramP2PRoutes_Route::legacy_score() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramP2PRoutes.Route.legacy_score)
  return _internal_legacy_score();
}
inline void CMsgSteamDatagramP2PRoutes_Route::_internal_set_legacy_score(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.legacy_score_ = value;
}
inline void CMsgSteamDatagramP2PRoutes_Route::set_legacy_score(uint32_t value) {
  _internal_set_legacy_score(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramP2PRoutes.Route.legacy_score)
}

// optional uint32 interior_score = 4;
inline bool CMsgSteamDatagramP2PRoutes_Route::_internal_has_interior_score() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CMsgSteamDatagramP2PRoutes_Route::has_interior_score() const {
  return _internal_has_interior_score();
}
inline void CMsgSteamDatagramP2PRoutes_Route::clear_interior_score() {
  _impl_.interior_score_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t CMsgSteamDatagramP2PRoutes_Route::_internal_interior_score() const {
  return _impl_.interior_score_;
}
inline uint32_t CMsgSteamDatagramP2PRoutes_Route::interior_score() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramP2PRoutes.Route.interior_score)
  return _internal_interior_score();
}
inline void CMsgSteamDatagramP2PRoutes_Route::_internal_set_interior_score(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.interior_score_ = value;
}
inline void CMsgSteamDatagramP2PRoutes_Route::set_interior_score(uint32_t value) {
  _internal_set_interior_score(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramP2PRoutes.Route.interior_score)
}

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

// CMsgSteamDatagramP2PRoutes

// repeated .CMsgSteamDatagramP2PRoutes.RelayCluster relay_clusters = 1;
inline int CMsgSteamDatagramP2PRoutes::_internal_relay_clusters_size() const {
  return _impl_.relay_clusters_.size();
}
inline int CMsgSteamDatagramP2PRoutes::relay_clusters_size() const {
  return _internal_relay_clusters_size();
}
inline void CMsgSteamDatagramP2PRoutes::clear_relay_clusters() {
  _impl_.relay_clusters_.Clear();
}
inline ::CMsgSteamDatagramP2PRoutes_RelayCluster* CMsgSteamDatagramP2PRoutes::mutable_relay_clusters(int index) {
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramP2PRoutes.relay_clusters)
  return _impl_.relay_clusters_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgSteamDatagramP2PRoutes_RelayCluster >*
CMsgSteamDatagramP2PRoutes::mutable_relay_clusters() {
  // @@protoc_insertion_point(field_mutable_list:CMsgSteamDatagramP2PRoutes.relay_clusters)
  return &_impl_.relay_clusters_;
}
inline const ::CMsgSteamDatagramP2PRoutes_RelayCluster& CMsgSteamDatagramP2PRoutes::_internal_relay_clusters(int index) const {
  return _impl_.relay_clusters_.Get(index);
}
inline const ::CMsgSteamDatagramP2PRoutes_RelayCluster& CMsgSteamDatagramP2PRoutes::relay_clusters(int index) const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramP2PRoutes.relay_clusters)
  return _internal_relay_clusters(index);
}
inline ::CMsgSteamDatagramP2PRoutes_RelayCluster* CMsgSteamDatagramP2PRoutes::_internal_add_relay_clusters() {
  return _impl_.relay_clusters_.Add();
}
inline ::CMsgSteamDatagramP2PRoutes_RelayCluster* CMsgSteamDatagramP2PRoutes::add_relay_clusters() {
  ::CMsgSteamDatagramP2PRoutes_RelayCluster* _add = _internal_add_relay_clusters();
  // @@protoc_insertion_point(field_add:CMsgSteamDatagramP2PRoutes.relay_clusters)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgSteamDatagramP2PRoutes_RelayCluster >&
CMsgSteamDatagramP2PRoutes::relay_clusters() const {
  // @@protoc_insertion_point(field_list:CMsgSteamDatagramP2PRoutes.relay_clusters)
  return _impl_.relay_clusters_;
}

// repeated .CMsgSteamDatagramP2PRoutes.Route routes = 2;
inline int CMsgSteamDatagramP2PRoutes::_internal_routes_size() const {
  return _impl_.routes_.size();
}
inline int CMsgSteamDatagramP2PRoutes::routes_size() const {
  return _internal_routes_size();
}
inline void CMsgSteamDatagramP2PRoutes::clear_routes() {
  _impl_.routes_.Clear();
}
inline ::CMsgSteamDatagramP2PRoutes_Route* CMsgSteamDatagramP2PRoutes::mutable_routes(int index) {
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramP2PRoutes.routes)
  return _impl_.routes_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgSteamDatagramP2PRoutes_Route >*
CMsgSteamDatagramP2PRoutes::mutable_routes() {
  // @@protoc_insertion_point(field_mutable_list:CMsgSteamDatagramP2PRoutes.routes)
  return &_impl_.routes_;
}
inline const ::CMsgSteamDatagramP2PRoutes_Route& CMsgSteamDatagramP2PRoutes::_internal_routes(int index) const {
  return _impl_.routes_.Get(index);
}
inline const ::CMsgSteamDatagramP2PRoutes_Route& CMsgSteamDatagramP2PRoutes::routes(int index) const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramP2PRoutes.routes)
  return _internal_routes(index);
}
inline ::CMsgSteamDatagramP2PRoutes_Route* CMsgSteamDatagramP2PRoutes::_internal_add_routes() {
  return _impl_.routes_.Add();
}
inline ::CMsgSteamDatagramP2PRoutes_Route* CMsgSteamDatagramP2PRoutes::add_routes() {
  ::CMsgSteamDatagramP2PRoutes_Route* _add = _internal_add_routes();
  // @@protoc_insertion_point(field_add:CMsgSteamDatagramP2PRoutes.routes)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::CMsgSteamDatagramP2PRoutes_Route >&
CMsgSteamDatagramP2PRoutes::routes() const {
  // @@protoc_insertion_point(field_list:CMsgSteamDatagramP2PRoutes.routes)
  return _impl_.routes_;
}

// optional uint32 revision = 3;
inline bool CMsgSteamDatagramP2PRoutes::_internal_has_revision() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgSteamDatagramP2PRoutes::has_revision() const {
  return _internal_has_revision();
}
inline void CMsgSteamDatagramP2PRoutes::clear_revision() {
  _impl_.revision_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline uint32_t CMsgSteamDatagramP2PRoutes::_internal_revision() const {
  return _impl_.revision_;
}
inline uint32_t CMsgSteamDatagramP2PRoutes::revision() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramP2PRoutes.revision)
  return _internal_revision();
}
inline void CMsgSteamDatagramP2PRoutes::_internal_set_revision(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.revision_ = value;
}
inline void CMsgSteamDatagramP2PRoutes::set_revision(uint32_t value) {
  _internal_set_revision(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramP2PRoutes.revision)
}

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

// CMsgSteamDatagramSetSecondaryAddressRequest

// optional fixed32 client_main_ip = 1;
inline bool CMsgSteamDatagramSetSecondaryAddressRequest::_internal_has_client_main_ip() const {
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool CMsgSteamDatagramSetSecondaryAddressRequest::has_client_main_ip() const {
  return _internal_has_client_main_ip();
}
inline void CMsgSteamDatagramSetSecondaryAddressRequest::clear_client_main_ip() {
  _impl_.client_main_ip_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000004u;
}
inline uint32_t CMsgSteamDatagramSetSecondaryAddressRequest::_internal_client_main_ip() const {
  return _impl_.client_main_ip_;
}
inline uint32_t CMsgSteamDatagramSetSecondaryAddressRequest::client_main_ip() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramSetSecondaryAddressRequest.client_main_ip)
  return _internal_client_main_ip();
}
inline void CMsgSteamDatagramSetSecondaryAddressRequest::_internal_set_client_main_ip(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000004u;
  _impl_.client_main_ip_ = value;
}
inline void CMsgSteamDatagramSetSecondaryAddressRequest::set_client_main_ip(uint32_t value) {
  _internal_set_client_main_ip(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramSetSecondaryAddressRequest.client_main_ip)
}

// optional fixed32 client_main_port = 2;
inline bool CMsgSteamDatagramSetSecondaryAddressRequest::_internal_has_client_main_port() const {
  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool CMsgSteamDatagramSetSecondaryAddressRequest::has_client_main_port() const {
  return _internal_has_client_main_port();
}
inline void CMsgSteamDatagramSetSecondaryAddressRequest::clear_client_main_port() {
  _impl_.client_main_port_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000008u;
}
inline uint32_t CMsgSteamDatagramSetSecondaryAddressRequest::_internal_client_main_port() const {
  return _impl_.client_main_port_;
}
inline uint32_t CMsgSteamDatagramSetSecondaryAddressRequest::client_main_port() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramSetSecondaryAddressRequest.client_main_port)
  return _internal_client_main_port();
}
inline void CMsgSteamDatagramSetSecondaryAddressRequest::_internal_set_client_main_port(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000008u;
  _impl_.client_main_port_ = value;
}
inline void CMsgSteamDatagramSetSecondaryAddressRequest::set_client_main_port(uint32_t value) {
  _internal_set_client_main_port(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramSetSecondaryAddressRequest.client_main_port)
}

// optional fixed32 client_connection_id = 3;
inline bool CMsgSteamDatagramSetSecondaryAddressRequest::_internal_has_client_connection_id() const {
  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool CMsgSteamDatagramSetSecondaryAddressRequest::has_client_connection_id() const {
  return _internal_has_client_connection_id();
}
inline void CMsgSteamDatagramSetSecondaryAddressRequest::clear_client_connection_id() {
  _impl_.client_connection_id_ = 0u;
  _impl_._has_bits_[0] &= ~0x00000010u;
}
inline uint32_t CMsgSteamDatagramSetSecondaryAddressRequest::_internal_client_connection_id() const {
  return _impl_.client_connection_id_;
}
inline uint32_t CMsgSteamDatagramSetSecondaryAddressRequest::client_connection_id() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramSetSecondaryAddressRequest.client_connection_id)
  return _internal_client_connection_id();
}
inline void CMsgSteamDatagramSetSecondaryAddressRequest::_internal_set_client_connection_id(uint32_t value) {
  _impl_._has_bits_[0] |= 0x00000010u;
  _impl_.client_connection_id_ = value;
}
inline void CMsgSteamDatagramSetSecondaryAddressRequest::set_client_connection_id(uint32_t value) {
  _internal_set_client_connection_id(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramSetSecondaryAddressRequest.client_connection_id)
}

// optional string client_identity = 4;
inline bool CMsgSteamDatagramSetSecondaryAddressRequest::_internal_has_client_identity() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgSteamDatagramSetSecondaryAddressRequest::has_client_identity() const {
  return _internal_has_client_identity();
}
inline void CMsgSteamDatagramSetSecondaryAddressRequest::clear_client_identity() {
  _impl_.client_identity_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CMsgSteamDatagramSetSecondaryAddressRequest::client_identity() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramSetSecondaryAddressRequest.client_identity)
  return _internal_client_identity();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgSteamDatagramSetSecondaryAddressRequest::set_client_identity(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.client_identity_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramSetSecondaryAddressRequest.client_identity)
}
inline std::string* CMsgSteamDatagramSetSecondaryAddressRequest::mutable_client_identity() {
  std::string* _s = _internal_mutable_client_identity();
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramSetSecondaryAddressRequest.client_identity)
  return _s;
}
inline const std::string& CMsgSteamDatagramSetSecondaryAddressRequest::_internal_client_identity() const {
  return _impl_.client_identity_.Get();
}
inline void CMsgSteamDatagramSetSecondaryAddressRequest::_internal_set_client_identity(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.client_identity_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramSetSecondaryAddressRequest::_internal_mutable_client_identity() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.client_identity_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramSetSecondaryAddressRequest::release_client_identity() {
  // @@protoc_insertion_point(field_release:CMsgSteamDatagramSetSecondaryAddressRequest.client_identity)
  if (!_internal_has_client_identity()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.client_identity_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.client_identity_.IsDefault()) {
    _impl_.client_identity_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgSteamDatagramSetSecondaryAddressRequest::set_allocated_client_identity(std::string* client_identity) {
  if (client_identity != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.client_identity_.SetAllocated(client_identity, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.client_identity_.IsDefault()) {
    _impl_.client_identity_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamDatagramSetSecondaryAddressRequest.client_identity)
}

// optional bool request_send_duplication = 5;
inline bool CMsgSteamDatagramSetSecondaryAddressRequest::_internal_has_request_send_duplication() const {
  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool CMsgSteamDatagramSetSecondaryAddressRequest::has_request_send_duplication() const {
  return _internal_has_request_send_duplication();
}
inline void CMsgSteamDatagramSetSecondaryAddressRequest::clear_request_send_duplication() {
  _impl_.request_send_duplication_ = false;
  _impl_._has_bits_[0] &= ~0x00000020u;
}
inline bool CMsgSteamDatagramSetSecondaryAddressRequest::_internal_request_send_duplication() const {
  return _impl_.request_send_duplication_;
}
inline bool CMsgSteamDatagramSetSecondaryAddressRequest::request_send_duplication() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramSetSecondaryAddressRequest.request_send_duplication)
  return _internal_request_send_duplication();
}
inline void CMsgSteamDatagramSetSecondaryAddressRequest::_internal_set_request_send_duplication(bool value) {
  _impl_._has_bits_[0] |= 0x00000020u;
  _impl_.request_send_duplication_ = value;
}
inline void CMsgSteamDatagramSetSecondaryAddressRequest::set_request_send_duplication(bool value) {
  _internal_set_request_send_duplication(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramSetSecondaryAddressRequest.request_send_duplication)
}

// optional bytes kludge_pad = 99;
inline bool CMsgSteamDatagramSetSecondaryAddressRequest::_internal_has_kludge_pad() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgSteamDatagramSetSecondaryAddressRequest::has_kludge_pad() const {
  return _internal_has_kludge_pad();
}
inline void CMsgSteamDatagramSetSecondaryAddressRequest::clear_kludge_pad() {
  _impl_.kludge_pad_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline const std::string& CMsgSteamDatagramSetSecondaryAddressRequest::kludge_pad() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramSetSecondaryAddressRequest.kludge_pad)
  return _internal_kludge_pad();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgSteamDatagramSetSecondaryAddressRequest::set_kludge_pad(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000002u;
 _impl_.kludge_pad_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramSetSecondaryAddressRequest.kludge_pad)
}
inline std::string* CMsgSteamDatagramSetSecondaryAddressRequest::mutable_kludge_pad() {
  std::string* _s = _internal_mutable_kludge_pad();
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramSetSecondaryAddressRequest.kludge_pad)
  return _s;
}
inline const std::string& CMsgSteamDatagramSetSecondaryAddressRequest::_internal_kludge_pad() const {
  return _impl_.kludge_pad_.Get();
}
inline void CMsgSteamDatagramSetSecondaryAddressRequest::_internal_set_kludge_pad(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.kludge_pad_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramSetSecondaryAddressRequest::_internal_mutable_kludge_pad() {
  _impl_._has_bits_[0] |= 0x00000002u;
  return _impl_.kludge_pad_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramSetSecondaryAddressRequest::release_kludge_pad() {
  // @@protoc_insertion_point(field_release:CMsgSteamDatagramSetSecondaryAddressRequest.kludge_pad)
  if (!_internal_has_kludge_pad()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000002u;
  auto* p = _impl_.kludge_pad_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.kludge_pad_.IsDefault()) {
    _impl_.kludge_pad_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgSteamDatagramSetSecondaryAddressRequest::set_allocated_kludge_pad(std::string* kludge_pad) {
  if (kludge_pad != nullptr) {
    _impl_._has_bits_[0] |= 0x00000002u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000002u;
  }
  _impl_.kludge_pad_.SetAllocated(kludge_pad, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.kludge_pad_.IsDefault()) {
    _impl_.kludge_pad_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamDatagramSetSecondaryAddressRequest.kludge_pad)
}

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

// CMsgSteamDatagramSetSecondaryAddressResult

// optional bool success = 1;
inline bool CMsgSteamDatagramSetSecondaryAddressResult::_internal_has_success() const {
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool CMsgSteamDatagramSetSecondaryAddressResult::has_success() const {
  return _internal_has_success();
}
inline void CMsgSteamDatagramSetSecondaryAddressResult::clear_success() {
  _impl_.success_ = false;
  _impl_._has_bits_[0] &= ~0x00000002u;
}
inline bool CMsgSteamDatagramSetSecondaryAddressResult::_internal_success() const {
  return _impl_.success_;
}
inline bool CMsgSteamDatagramSetSecondaryAddressResult::success() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramSetSecondaryAddressResult.success)
  return _internal_success();
}
inline void CMsgSteamDatagramSetSecondaryAddressResult::_internal_set_success(bool value) {
  _impl_._has_bits_[0] |= 0x00000002u;
  _impl_.success_ = value;
}
inline void CMsgSteamDatagramSetSecondaryAddressResult::set_success(bool value) {
  _internal_set_success(value);
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramSetSecondaryAddressResult.success)
}

// optional string message = 2;
inline bool CMsgSteamDatagramSetSecondaryAddressResult::_internal_has_message() const {
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool CMsgSteamDatagramSetSecondaryAddressResult::has_message() const {
  return _internal_has_message();
}
inline void CMsgSteamDatagramSetSecondaryAddressResult::clear_message() {
  _impl_.message_.ClearToEmpty();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
inline const std::string& CMsgSteamDatagramSetSecondaryAddressResult::message() const {
  // @@protoc_insertion_point(field_get:CMsgSteamDatagramSetSecondaryAddressResult.message)
  return _internal_message();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CMsgSteamDatagramSetSecondaryAddressResult::set_message(ArgT0&& arg0, ArgT... args) {
 _impl_._has_bits_[0] |= 0x00000001u;
 _impl_.message_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:CMsgSteamDatagramSetSecondaryAddressResult.message)
}
inline std::string* CMsgSteamDatagramSetSecondaryAddressResult::mutable_message() {
  std::string* _s = _internal_mutable_message();
  // @@protoc_insertion_point(field_mutable:CMsgSteamDatagramSetSecondaryAddressResult.message)
  return _s;
}
inline const std::string& CMsgSteamDatagramSetSecondaryAddressResult::_internal_message() const {
  return _impl_.message_.Get();
}
inline void CMsgSteamDatagramSetSecondaryAddressResult::_internal_set_message(const std::string& value) {
  _impl_._has_bits_[0] |= 0x00000001u;
  _impl_.message_.Set(value, GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramSetSecondaryAddressResult::_internal_mutable_message() {
  _impl_._has_bits_[0] |= 0x00000001u;
  return _impl_.message_.Mutable(GetArenaForAllocation());
}
inline std::string* CMsgSteamDatagramSetSecondaryAddressResult::release_message() {
  // @@protoc_insertion_point(field_release:CMsgSteamDatagramSetSecondaryAddressResult.message)
  if (!_internal_has_message()) {
    return nullptr;
  }
  _impl_._has_bits_[0] &= ~0x00000001u;
  auto* p = _impl_.message_.Release();
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.message_.IsDefault()) {
    _impl_.message_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void CMsgSteamDatagramSetSecondaryAddressResult::set_allocated_message(std::string* message) {
  if (message != nullptr) {
    _impl_._has_bits_[0] |= 0x00000001u;
  } else {
    _impl_._has_bits_[0] &= ~0x00000001u;
  }
  _impl_.message_.SetAllocated(message, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (_impl_.message_.IsDefault()) {
    _impl_.message_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:CMsgSteamDatagramSetSecondaryAddressResult.message)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)


PROTOBUF_NAMESPACE_OPEN

template <> struct is_proto_enum< ::CMsgSteamDatagramRouterPingReply_AltAddress_Protocol> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::CMsgSteamDatagramRouterPingReply_AltAddress_Protocol>() {
  return ::CMsgSteamDatagramRouterPingReply_AltAddress_Protocol_descriptor();
}
template <> struct is_proto_enum< ::CMsgSteamDatagramRouterPingReply_Flags> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::CMsgSteamDatagramRouterPingReply_Flags>() {
  return ::CMsgSteamDatagramRouterPingReply_Flags_descriptor();
}
template <> struct is_proto_enum< ::CMsgSteamDatagramConnectionClosed_ERelayMode> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::CMsgSteamDatagramConnectionClosed_ERelayMode>() {
  return ::CMsgSteamDatagramConnectionClosed_ERelayMode_descriptor();
}
template <> struct is_proto_enum< ::CMsgSteamDatagramConnectionStatsClientToRouter_Flags> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::CMsgSteamDatagramConnectionStatsClientToRouter_Flags>() {
  return ::CMsgSteamDatagramConnectionStatsClientToRouter_Flags_descriptor();
}
template <> struct is_proto_enum< ::CMsgSteamDatagramConnectionStatsRouterToClient_Flags> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::CMsgSteamDatagramConnectionStatsRouterToClient_Flags>() {
  return ::CMsgSteamDatagramConnectionStatsRouterToClient_Flags_descriptor();
}
template <> struct is_proto_enum< ::CMsgSteamDatagramConnectionStatsRouterToServer_Flags> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::CMsgSteamDatagramConnectionStatsRouterToServer_Flags>() {
  return ::CMsgSteamDatagramConnectionStatsRouterToServer_Flags_descriptor();
}
template <> struct is_proto_enum< ::CMsgSteamDatagramConnectionStatsServerToRouter_Flags> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::CMsgSteamDatagramConnectionStatsServerToRouter_Flags>() {
  return ::CMsgSteamDatagramConnectionStatsServerToRouter_Flags_descriptor();
}
template <> struct is_proto_enum< ::CMsgSteamDatagramConnectionStatsP2PClientToRouter_Flags> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::CMsgSteamDatagramConnectionStatsP2PClientToRouter_Flags>() {
  return ::CMsgSteamDatagramConnectionStatsP2PClientToRouter_Flags_descriptor();
}
template <> struct is_proto_enum< ::CMsgSteamDatagramConnectionStatsP2PRouterToClient_Flags> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::CMsgSteamDatagramConnectionStatsP2PRouterToClient_Flags>() {
  return ::CMsgSteamDatagramConnectionStatsP2PRouterToClient_Flags_descriptor();
}
template <> struct is_proto_enum< ::ESteamDatagramMsgID> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::ESteamDatagramMsgID>() {
  return ::ESteamDatagramMsgID_descriptor();
}

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

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