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

#include "steamnetworkingsockets_messages_udp.pb.h"

#include <algorithm>

#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/extension_set.h>
#include <google/protobuf/wire_format_lite.h>
#include <google/protobuf/descriptor.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/reflection_ops.h>
#include <google/protobuf/wire_format.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>

PROTOBUF_PRAGMA_INIT_SEG

namespace _pb = ::PROTOBUF_NAMESPACE_ID;
namespace _pbi = _pb::internal;

PROTOBUF_CONSTEXPR CMsgSteamSockets_UDP_ChallengeRequest::CMsgSteamSockets_UDP_ChallengeRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.connection_id_)*/0u
  , /*decltype(_impl_.protocol_version_)*/0u
  , /*decltype(_impl_.my_timestamp_)*/uint64_t{0u}} {}
struct CMsgSteamSockets_UDP_ChallengeRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR CMsgSteamSockets_UDP_ChallengeRequestDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~CMsgSteamSockets_UDP_ChallengeRequestDefaultTypeInternal() {}
  union {
    CMsgSteamSockets_UDP_ChallengeRequest _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CMsgSteamSockets_UDP_ChallengeRequestDefaultTypeInternal _CMsgSteamSockets_UDP_ChallengeRequest_default_instance_;
PROTOBUF_CONSTEXPR CMsgSteamSockets_UDP_ChallengeReply::CMsgSteamSockets_UDP_ChallengeReply(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.challenge_)*/uint64_t{0u}
  , /*decltype(_impl_.connection_id_)*/0u
  , /*decltype(_impl_.protocol_version_)*/0u
  , /*decltype(_impl_.your_timestamp_)*/uint64_t{0u}} {}
struct CMsgSteamSockets_UDP_ChallengeReplyDefaultTypeInternal {
  PROTOBUF_CONSTEXPR CMsgSteamSockets_UDP_ChallengeReplyDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~CMsgSteamSockets_UDP_ChallengeReplyDefaultTypeInternal() {}
  union {
    CMsgSteamSockets_UDP_ChallengeReply _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CMsgSteamSockets_UDP_ChallengeReplyDefaultTypeInternal _CMsgSteamSockets_UDP_ChallengeReply_default_instance_;
PROTOBUF_CONSTEXPR CMsgSteamSockets_UDP_ConnectRequest::CMsgSteamSockets_UDP_ConnectRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.identity_string_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
  , /*decltype(_impl_.cert_)*/nullptr
  , /*decltype(_impl_.crypt_)*/nullptr
  , /*decltype(_impl_.legacy_identity_binary_)*/nullptr
  , /*decltype(_impl_.challenge_)*/uint64_t{0u}
  , /*decltype(_impl_.legacy_client_steam_id_)*/uint64_t{0u}
  , /*decltype(_impl_.client_connection_id_)*/0u
  , /*decltype(_impl_.ping_est_ms_)*/0u
  , /*decltype(_impl_.my_timestamp_)*/uint64_t{0u}
  , /*decltype(_impl_.legacy_protocol_version_)*/0u} {}
struct CMsgSteamSockets_UDP_ConnectRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR CMsgSteamSockets_UDP_ConnectRequestDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~CMsgSteamSockets_UDP_ConnectRequestDefaultTypeInternal() {}
  union {
    CMsgSteamSockets_UDP_ConnectRequest _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CMsgSteamSockets_UDP_ConnectRequestDefaultTypeInternal _CMsgSteamSockets_UDP_ConnectRequest_default_instance_;
PROTOBUF_CONSTEXPR CMsgSteamSockets_UDP_ConnectOK::CMsgSteamSockets_UDP_ConnectOK(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.identity_string_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
  , /*decltype(_impl_.crypt_)*/nullptr
  , /*decltype(_impl_.cert_)*/nullptr
  , /*decltype(_impl_.legacy_identity_binary_)*/nullptr
  , /*decltype(_impl_.legacy_server_steam_id_)*/uint64_t{0u}
  , /*decltype(_impl_.client_connection_id_)*/0u
  , /*decltype(_impl_.delay_time_usec_)*/0u
  , /*decltype(_impl_.your_timestamp_)*/uint64_t{0u}
  , /*decltype(_impl_.server_connection_id_)*/0u} {}
struct CMsgSteamSockets_UDP_ConnectOKDefaultTypeInternal {
  PROTOBUF_CONSTEXPR CMsgSteamSockets_UDP_ConnectOKDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~CMsgSteamSockets_UDP_ConnectOKDefaultTypeInternal() {}
  union {
    CMsgSteamSockets_UDP_ConnectOK _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CMsgSteamSockets_UDP_ConnectOKDefaultTypeInternal _CMsgSteamSockets_UDP_ConnectOK_default_instance_;
PROTOBUF_CONSTEXPR CMsgSteamSockets_UDP_ConnectionClosed::CMsgSteamSockets_UDP_ConnectionClosed(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.debug_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
  , /*decltype(_impl_.reason_code_)*/0u
  , /*decltype(_impl_.to_connection_id_)*/0u
  , /*decltype(_impl_.from_connection_id_)*/0u} {}
struct CMsgSteamSockets_UDP_ConnectionClosedDefaultTypeInternal {
  PROTOBUF_CONSTEXPR CMsgSteamSockets_UDP_ConnectionClosedDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~CMsgSteamSockets_UDP_ConnectionClosedDefaultTypeInternal() {}
  union {
    CMsgSteamSockets_UDP_ConnectionClosed _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CMsgSteamSockets_UDP_ConnectionClosedDefaultTypeInternal _CMsgSteamSockets_UDP_ConnectionClosed_default_instance_;
PROTOBUF_CONSTEXPR CMsgSteamSockets_UDP_NoConnection::CMsgSteamSockets_UDP_NoConnection(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.from_connection_id_)*/0u
  , /*decltype(_impl_.to_connection_id_)*/0u} {}
struct CMsgSteamSockets_UDP_NoConnectionDefaultTypeInternal {
  PROTOBUF_CONSTEXPR CMsgSteamSockets_UDP_NoConnectionDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~CMsgSteamSockets_UDP_NoConnectionDefaultTypeInternal() {}
  union {
    CMsgSteamSockets_UDP_NoConnection _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CMsgSteamSockets_UDP_NoConnectionDefaultTypeInternal _CMsgSteamSockets_UDP_NoConnection_default_instance_;
PROTOBUF_CONSTEXPR CMsgSteamSockets_UDP_Stats::CMsgSteamSockets_UDP_Stats(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.stats_)*/nullptr
  , /*decltype(_impl_.flags_)*/0u} {}
struct CMsgSteamSockets_UDP_StatsDefaultTypeInternal {
  PROTOBUF_CONSTEXPR CMsgSteamSockets_UDP_StatsDefaultTypeInternal()
      : _instance(::_pbi::ConstantInitialized{}) {}
  ~CMsgSteamSockets_UDP_StatsDefaultTypeInternal() {}
  union {
    CMsgSteamSockets_UDP_Stats _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CMsgSteamSockets_UDP_StatsDefaultTypeInternal _CMsgSteamSockets_UDP_Stats_default_instance_;
static ::_pb::Metadata file_level_metadata_steamnetworkingsockets_5fmessages_5fudp_2eproto[7];
static const ::_pb::EnumDescriptor* file_level_enum_descriptors_steamnetworkingsockets_5fmessages_5fudp_2eproto[2];
static constexpr ::_pb::ServiceDescriptor const** file_level_service_descriptors_steamnetworkingsockets_5fmessages_5fudp_2eproto = nullptr;

const uint32_t TableStruct_steamnetworkingsockets_5fmessages_5fudp_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
  PROTOBUF_FIELD_OFFSET(::CMsgSteamSockets_UDP_ChallengeRequest, _impl_._has_bits_),
  PROTOBUF_FIELD_OFFSET(::CMsgSteamSockets_UDP_ChallengeRequest, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::CMsgSteamSockets_UDP_ChallengeRequest, _impl_.connection_id_),
  PROTOBUF_FIELD_OFFSET(::CMsgSteamSockets_UDP_ChallengeRequest, _impl_.my_timestamp_),
  PROTOBUF_FIELD_OFFSET(::CMsgSteamSockets_UDP_ChallengeRequest, _impl_.protocol_version_),
  0,
  2,
  1,
  PROTOBUF_FIELD_OFFSET(::CMsgSteamSockets_UDP_ChallengeReply, _impl_._has_bits_),
  PROTOBUF_FIELD_OFFSET(::CMsgSteamSockets_UDP_ChallengeReply, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::CMsgSteamSockets_UDP_ChallengeReply, _impl_.connection_id_),
  PROTOBUF_FIELD_OFFSET(::CMsgSteamSockets_UDP_ChallengeReply, _impl_.challenge_),
  PROTOBUF_FIELD_OFFSET(::CMsgSteamSockets_UDP_ChallengeReply, _impl_.your_timestamp_),
  PROTOBUF_FIELD_OFFSET(::CMsgSteamSockets_UDP_ChallengeReply, _impl_.protocol_version_),
  1,
  0,
  3,
  2,
  PROTOBUF_FIELD_OFFSET(::CMsgSteamSockets_UDP_ConnectRequest, _impl_._has_bits_),
  PROTOBUF_FIELD_OFFSET(::CMsgSteamSockets_UDP_ConnectRequest, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::CMsgSteamSockets_UDP_ConnectRequest, _impl_.client_connection_id_),
  PROTOBUF_FIELD_OFFSET(::CMsgSteamSockets_UDP_ConnectRequest, _impl_.challenge_),
  PROTOBUF_FIELD_OFFSET(::CMsgSteamSockets_UDP_ConnectRequest, _impl_.my_timestamp_),
  PROTOBUF_FIELD_OFFSET(::CMsgSteamSockets_UDP_ConnectRequest, _impl_.ping_est_ms_),
  PROTOBUF_FIELD_OFFSET(::CMsgSteamSockets_UDP_ConnectRequest, _impl_.crypt_),
  PROTOBUF_FIELD_OFFSET(::CMsgSteamSockets_UDP_ConnectRequest, _impl_.cert_),
  PROTOBUF_FIELD_OFFSET(::CMsgSteamSockets_UDP_ConnectRequest, _impl_.legacy_protocol_version_),
  PROTOBUF_FIELD_OFFSET(::CMsgSteamSockets_UDP_ConnectRequest, _impl_.identity_string_),
  PROTOBUF_FIELD_OFFSET(::CMsgSteamSockets_UDP_ConnectRequest, _impl_.legacy_client_steam_id_),
  PROTOBUF_FIELD_OFFSET(::CMsgSteamSockets_UDP_ConnectRequest, _impl_.legacy_identity_binary_),
  6,
  4,
  8,
  7,
  2,
  1,
  9,
  0,
  5,
  3,
  PROTOBUF_FIELD_OFFSET(::CMsgSteamSockets_UDP_ConnectOK, _impl_._has_bits_),
  PROTOBUF_FIELD_OFFSET(::CMsgSteamSockets_UDP_ConnectOK, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::CMsgSteamSockets_UDP_ConnectOK, _impl_.client_connection_id_),
  PROTOBUF_FIELD_OFFSET(::CMsgSteamSockets_UDP_ConnectOK, _impl_.server_connection_id_),
  PROTOBUF_FIELD_OFFSET(::CMsgSteamSockets_UDP_ConnectOK, _impl_.your_timestamp_),
  PROTOBUF_FIELD_OFFSET(::CMsgSteamSockets_UDP_ConnectOK, _impl_.delay_time_usec_),
  PROTOBUF_FIELD_OFFSET(::CMsgSteamSockets_UDP_ConnectOK, _impl_.crypt_),
  PROTOBUF_FIELD_OFFSET(::CMsgSteamSockets_UDP_ConnectOK, _impl_.cert_),
  PROTOBUF_FIELD_OFFSET(::CMsgSteamSockets_UDP_ConnectOK, _impl_.identity_string_),
  PROTOBUF_FIELD_OFFSET(::CMsgSteamSockets_UDP_ConnectOK, _impl_.legacy_server_steam_id_),
  PROTOBUF_FIELD_OFFSET(::CMsgSteamSockets_UDP_ConnectOK, _impl_.legacy_identity_binary_),
  5,
  8,
  7,
  6,
  1,
  2,
  0,
  4,
  3,
  PROTOBUF_FIELD_OFFSET(::CMsgSteamSockets_UDP_ConnectionClosed, _impl_._has_bits_),
  PROTOBUF_FIELD_OFFSET(::CMsgSteamSockets_UDP_ConnectionClosed, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::CMsgSteamSockets_UDP_ConnectionClosed, _impl_.to_connection_id_),
  PROTOBUF_FIELD_OFFSET(::CMsgSteamSockets_UDP_ConnectionClosed, _impl_.from_connection_id_),
  PROTOBUF_FIELD_OFFSET(::CMsgSteamSockets_UDP_ConnectionClosed, _impl_.debug_),
  PROTOBUF_FIELD_OFFSET(::CMsgSteamSockets_UDP_ConnectionClosed, _impl_.reason_code_),
  2,
  3,
  0,
  1,
  PROTOBUF_FIELD_OFFSET(::CMsgSteamSockets_UDP_NoConnection, _impl_._has_bits_),
  PROTOBUF_FIELD_OFFSET(::CMsgSteamSockets_UDP_NoConnection, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::CMsgSteamSockets_UDP_NoConnection, _impl_.from_connection_id_),
  PROTOBUF_FIELD_OFFSET(::CMsgSteamSockets_UDP_NoConnection, _impl_.to_connection_id_),
  0,
  1,
  PROTOBUF_FIELD_OFFSET(::CMsgSteamSockets_UDP_Stats, _impl_._has_bits_),
  PROTOBUF_FIELD_OFFSET(::CMsgSteamSockets_UDP_Stats, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::CMsgSteamSockets_UDP_Stats, _impl_.stats_),
  PROTOBUF_FIELD_OFFSET(::CMsgSteamSockets_UDP_Stats, _impl_.flags_),
  0,
  1,
};
static const ::_pbi::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
  { 0, 9, -1, sizeof(::CMsgSteamSockets_UDP_ChallengeRequest)},
  { 12, 22, -1, sizeof(::CMsgSteamSockets_UDP_ChallengeReply)},
  { 26, 42, -1, sizeof(::CMsgSteamSockets_UDP_ConnectRequest)},
  { 52, 67, -1, sizeof(::CMsgSteamSockets_UDP_ConnectOK)},
  { 76, 86, -1, sizeof(::CMsgSteamSockets_UDP_ConnectionClosed)},
  { 90, 98, -1, sizeof(::CMsgSteamSockets_UDP_NoConnection)},
  { 100, 108, -1, sizeof(::CMsgSteamSockets_UDP_Stats)},
};

static const ::_pb::Message* const file_default_instances[] = {
  &::_CMsgSteamSockets_UDP_ChallengeRequest_default_instance_._instance,
  &::_CMsgSteamSockets_UDP_ChallengeReply_default_instance_._instance,
  &::_CMsgSteamSockets_UDP_ConnectRequest_default_instance_._instance,
  &::_CMsgSteamSockets_UDP_ConnectOK_default_instance_._instance,
  &::_CMsgSteamSockets_UDP_ConnectionClosed_default_instance_._instance,
  &::_CMsgSteamSockets_UDP_NoConnection_default_instance_._instance,
  &::_CMsgSteamSockets_UDP_Stats_default_instance_._instance,
};

const char descriptor_table_protodef_steamnetworkingsockets_5fmessages_5fudp_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) =
  "\n)steamnetworkingsockets_messages_udp.pr"
  "oto\032+steamnetworkingsockets_messages_cer"
  "ts.proto\032%steamnetworkingsockets_message"
  "s.proto\"n\n%CMsgSteamSockets_UDP_Challeng"
  "eRequest\022\025\n\rconnection_id\030\001 \001(\007\022\024\n\014my_ti"
  "mestamp\030\003 \001(\006\022\030\n\020protocol_version\030\004 \001(\r\""
  "\201\001\n#CMsgSteamSockets_UDP_ChallengeReply\022"
  "\025\n\rconnection_id\030\001 \001(\007\022\021\n\tchallenge\030\002 \001("
  "\006\022\026\n\016your_timestamp\030\003 \001(\006\022\030\n\020protocol_ve"
  "rsion\030\004 \001(\r\"\221\003\n#CMsgSteamSockets_UDP_Con"
  "nectRequest\022\034\n\024client_connection_id\030\001 \001("
  "\007\022\021\n\tchallenge\030\002 \001(\006\022\024\n\014my_timestamp\030\005 \001"
  "(\006\022\023\n\013ping_est_ms\030\006 \001(\r\0227\n\005crypt\030\007 \001(\0132("
  ".CMsgSteamDatagramSessionCryptInfoSigned"
  "\0221\n\004cert\030\004 \001(\0132#.CMsgSteamDatagramCertif"
  "icateSigned\022\037\n\027legacy_protocol_version\030\010"
  " \001(\r\022\027\n\017identity_string\030\n \001(\t\022\036\n\026legacy_"
  "client_steam_id\030\003 \001(\006\022H\n\026legacy_identity"
  "_binary\030\t \001(\0132(.CMsgSteamNetworkingIdent"
  "ityLegacyBinary\"\374\002\n\036CMsgSteamSockets_UDP"
  "_ConnectOK\022\034\n\024client_connection_id\030\001 \001(\007"
  "\022\034\n\024server_connection_id\030\005 \001(\007\022\026\n\016your_t"
  "imestamp\030\003 \001(\006\022\027\n\017delay_time_usec\030\004 \001(\r\022"
  "7\n\005crypt\030\007 \001(\0132(.CMsgSteamDatagramSessio"
  "nCryptInfoSigned\0221\n\004cert\030\010 \001(\0132#.CMsgSte"
  "amDatagramCertificateSigned\022\027\n\017identity_"
  "string\030\013 \001(\t\022\036\n\026legacy_server_steam_id\030\002"
  " \001(\006\022H\n\026legacy_identity_binary\030\n \001(\0132(.C"
  "MsgSteamNetworkingIdentityLegacyBinary\"\201"
  "\001\n%CMsgSteamSockets_UDP_ConnectionClosed"
  "\022\030\n\020to_connection_id\030\004 \001(\007\022\032\n\022from_conne"
  "ction_id\030\005 \001(\007\022\r\n\005debug\030\002 \001(\t\022\023\n\013reason_"
  "code\030\003 \001(\r\"Y\n!CMsgSteamSockets_UDP_NoCon"
  "nection\022\032\n\022from_connection_id\030\002 \001(\007\022\030\n\020t"
  "o_connection_id\030\003 \001(\007\"\267\001\n\032CMsgSteamSocke"
  "ts_UDP_Stats\0222\n\005stats\030\001 \001(\0132#.CMsgSteamD"
  "atagramConnectionQuality\022\r\n\005flags\030\003 \001(\r\""
  "V\n\005Flags\022\023\n\017ACK_REQUEST_E2E\020\002\022\031\n\025ACK_REQ"
  "UEST_IMMEDIATE\020\004\022\035\n\031NOT_PRIMARY_TRANSPOR"
  "T_E2E\020\020*\245\002\n\030ESteamNetworkingUDPMsgID\022-\n)"
  "k_ESteamNetworkingUDPMsg_ChallengeReques"
  "t\020 \022+\n\'k_ESteamNetworkingUDPMsg_Challeng"
  "eReply\020!\022+\n\'k_ESteamNetworkingUDPMsg_Con"
  "nectRequest\020\"\022&\n\"k_ESteamNetworkingUDPMs"
  "g_ConnectOK\020#\022-\n)k_ESteamNetworkingUDPMs"
  "g_ConnectionClosed\020$\022)\n%k_ESteamNetworki"
  "ngUDPMsg_NoConnection\020%B\005H\001\200\001\000"
  ;
static const ::_pbi::DescriptorTable* const descriptor_table_steamnetworkingsockets_5fmessages_5fudp_2eproto_deps[2] = {
  &::descriptor_table_steamnetworkingsockets_5fmessages_2eproto,
  &::descriptor_table_steamnetworkingsockets_5fmessages_5fcerts_2eproto,
};
static ::_pbi::once_flag descriptor_table_steamnetworkingsockets_5fmessages_5fudp_2eproto_once;
const ::_pbi::DescriptorTable descriptor_table_steamnetworkingsockets_5fmessages_5fudp_2eproto = {
    false, false, 1870, descriptor_table_protodef_steamnetworkingsockets_5fmessages_5fudp_2eproto,
    "steamnetworkingsockets_messages_udp.proto",
    &descriptor_table_steamnetworkingsockets_5fmessages_5fudp_2eproto_once, descriptor_table_steamnetworkingsockets_5fmessages_5fudp_2eproto_deps, 2, 7,
    schemas, file_default_instances, TableStruct_steamnetworkingsockets_5fmessages_5fudp_2eproto::offsets,
    file_level_metadata_steamnetworkingsockets_5fmessages_5fudp_2eproto, file_level_enum_descriptors_steamnetworkingsockets_5fmessages_5fudp_2eproto,
    file_level_service_descriptors_steamnetworkingsockets_5fmessages_5fudp_2eproto,
};
PROTOBUF_ATTRIBUTE_WEAK const ::_pbi::DescriptorTable* descriptor_table_steamnetworkingsockets_5fmessages_5fudp_2eproto_getter() {
  return &descriptor_table_steamnetworkingsockets_5fmessages_5fudp_2eproto;
}

// Force running AddDescriptors() at dynamic initialization time.
PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 static ::_pbi::AddDescriptorsRunner dynamic_init_dummy_steamnetworkingsockets_5fmessages_5fudp_2eproto(&descriptor_table_steamnetworkingsockets_5fmessages_5fudp_2eproto);
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* CMsgSteamSockets_UDP_Stats_Flags_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_steamnetworkingsockets_5fmessages_5fudp_2eproto);
  return file_level_enum_descriptors_steamnetworkingsockets_5fmessages_5fudp_2eproto[0];
}
bool CMsgSteamSockets_UDP_Stats_Flags_IsValid(int value) {
  switch (value) {
    case 2:
    case 4:
    case 16:
      return true;
    default:
      return false;
  }
}

#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr CMsgSteamSockets_UDP_Stats_Flags CMsgSteamSockets_UDP_Stats::ACK_REQUEST_E2E;
constexpr CMsgSteamSockets_UDP_Stats_Flags CMsgSteamSockets_UDP_Stats::ACK_REQUEST_IMMEDIATE;
constexpr CMsgSteamSockets_UDP_Stats_Flags CMsgSteamSockets_UDP_Stats::NOT_PRIMARY_TRANSPORT_E2E;
constexpr CMsgSteamSockets_UDP_Stats_Flags CMsgSteamSockets_UDP_Stats::Flags_MIN;
constexpr CMsgSteamSockets_UDP_Stats_Flags CMsgSteamSockets_UDP_Stats::Flags_MAX;
constexpr int CMsgSteamSockets_UDP_Stats::Flags_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ESteamNetworkingUDPMsgID_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_steamnetworkingsockets_5fmessages_5fudp_2eproto);
  return file_level_enum_descriptors_steamnetworkingsockets_5fmessages_5fudp_2eproto[1];
}
bool ESteamNetworkingUDPMsgID_IsValid(int value) {
  switch (value) {
    case 32:
    case 33:
    case 34:
    case 35:
    case 36:
    case 37:
      return true;
    default:
      return false;
  }
}


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

class CMsgSteamSockets_UDP_ChallengeRequest::_Internal {
 public:
  using HasBits = decltype(std::declval<CMsgSteamSockets_UDP_ChallengeRequest>()._impl_._has_bits_);
  static void set_has_connection_id(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_my_timestamp(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_protocol_version(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
};

CMsgSteamSockets_UDP_ChallengeRequest::CMsgSteamSockets_UDP_ChallengeRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:CMsgSteamSockets_UDP_ChallengeRequest)
}
CMsgSteamSockets_UDP_ChallengeRequest::CMsgSteamSockets_UDP_ChallengeRequest(const CMsgSteamSockets_UDP_ChallengeRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  CMsgSteamSockets_UDP_ChallengeRequest* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){from._impl_._has_bits_}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.connection_id_){}
    , decltype(_impl_.protocol_version_){}
    , decltype(_impl_.my_timestamp_){}};

  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::memcpy(&_impl_.connection_id_, &from._impl_.connection_id_,
    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.my_timestamp_) -
    reinterpret_cast<char*>(&_impl_.connection_id_)) + sizeof(_impl_.my_timestamp_));
  // @@protoc_insertion_point(copy_constructor:CMsgSteamSockets_UDP_ChallengeRequest)
}

inline void CMsgSteamSockets_UDP_ChallengeRequest::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.connection_id_){0u}
    , decltype(_impl_.protocol_version_){0u}
    , decltype(_impl_.my_timestamp_){uint64_t{0u}}
  };
}

CMsgSteamSockets_UDP_ChallengeRequest::~CMsgSteamSockets_UDP_ChallengeRequest() {
  // @@protoc_insertion_point(destructor:CMsgSteamSockets_UDP_ChallengeRequest)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void CMsgSteamSockets_UDP_ChallengeRequest::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
}

void CMsgSteamSockets_UDP_ChallengeRequest::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void CMsgSteamSockets_UDP_ChallengeRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:CMsgSteamSockets_UDP_ChallengeRequest)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    ::memset(&_impl_.connection_id_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&_impl_.my_timestamp_) -
        reinterpret_cast<char*>(&_impl_.connection_id_)) + sizeof(_impl_.my_timestamp_));
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* CMsgSteamSockets_UDP_ChallengeRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional fixed32 connection_id = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 13)) {
          _Internal::set_has_connection_id(&has_bits);
          _impl_.connection_id_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<uint32_t>(ptr);
          ptr += sizeof(uint32_t);
        } else
          goto handle_unusual;
        continue;
      // optional fixed64 my_timestamp = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 25)) {
          _Internal::set_has_my_timestamp(&has_bits);
          _impl_.my_timestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<uint64_t>(ptr);
          ptr += sizeof(uint64_t);
        } else
          goto handle_unusual;
        continue;
      // optional uint32 protocol_version = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
          _Internal::set_has_protocol_version(&has_bits);
          _impl_.protocol_version_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _impl_._has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* CMsgSteamSockets_UDP_ChallengeRequest::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:CMsgSteamSockets_UDP_ChallengeRequest)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  // optional fixed32 connection_id = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteFixed32ToArray(1, this->_internal_connection_id(), target);
  }

  // optional fixed64 my_timestamp = 3;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteFixed64ToArray(3, this->_internal_my_timestamp(), target);
  }

  // optional uint32 protocol_version = 4;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(4, this->_internal_protocol_version(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:CMsgSteamSockets_UDP_ChallengeRequest)
  return target;
}

size_t CMsgSteamSockets_UDP_ChallengeRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:CMsgSteamSockets_UDP_ChallengeRequest)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    // optional fixed32 connection_id = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 + 4;
    }

    // optional uint32 protocol_version = 4;
    if (cached_has_bits & 0x00000002u) {
      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_protocol_version());
    }

    // optional fixed64 my_timestamp = 3;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 + 8;
    }

  }
  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData CMsgSteamSockets_UDP_ChallengeRequest::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
    CMsgSteamSockets_UDP_ChallengeRequest::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*CMsgSteamSockets_UDP_ChallengeRequest::GetClassData() const { return &_class_data_; }


void CMsgSteamSockets_UDP_ChallengeRequest::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
  auto* const _this = static_cast<CMsgSteamSockets_UDP_ChallengeRequest*>(&to_msg);
  auto& from = static_cast<const CMsgSteamSockets_UDP_ChallengeRequest&>(from_msg);
  // @@protoc_insertion_point(class_specific_merge_from_start:CMsgSteamSockets_UDP_ChallengeRequest)
  GOOGLE_DCHECK_NE(&from, _this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._impl_._has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      _this->_impl_.connection_id_ = from._impl_.connection_id_;
    }
    if (cached_has_bits & 0x00000002u) {
      _this->_impl_.protocol_version_ = from._impl_.protocol_version_;
    }
    if (cached_has_bits & 0x00000004u) {
      _this->_impl_.my_timestamp_ = from._impl_.my_timestamp_;
    }
    _this->_impl_._has_bits_[0] |= cached_has_bits;
  }
  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

bool CMsgSteamSockets_UDP_ChallengeRequest::IsInitialized() const {
  return true;
}

void CMsgSteamSockets_UDP_ChallengeRequest::InternalSwap(CMsgSteamSockets_UDP_ChallengeRequest* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(CMsgSteamSockets_UDP_ChallengeRequest, _impl_.my_timestamp_)
      + sizeof(CMsgSteamSockets_UDP_ChallengeRequest::_impl_.my_timestamp_)
      - PROTOBUF_FIELD_OFFSET(CMsgSteamSockets_UDP_ChallengeRequest, _impl_.connection_id_)>(
          reinterpret_cast<char*>(&_impl_.connection_id_),
          reinterpret_cast<char*>(&other->_impl_.connection_id_));
}

::PROTOBUF_NAMESPACE_ID::Metadata CMsgSteamSockets_UDP_ChallengeRequest::GetMetadata() const {
  return ::_pbi::AssignDescriptors(
      &descriptor_table_steamnetworkingsockets_5fmessages_5fudp_2eproto_getter, &descriptor_table_steamnetworkingsockets_5fmessages_5fudp_2eproto_once,
      file_level_metadata_steamnetworkingsockets_5fmessages_5fudp_2eproto[0]);
}

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

class CMsgSteamSockets_UDP_ChallengeReply::_Internal {
 public:
  using HasBits = decltype(std::declval<CMsgSteamSockets_UDP_ChallengeReply>()._impl_._has_bits_);
  static void set_has_connection_id(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_challenge(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_your_timestamp(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static void set_has_protocol_version(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
};

CMsgSteamSockets_UDP_ChallengeReply::CMsgSteamSockets_UDP_ChallengeReply(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:CMsgSteamSockets_UDP_ChallengeReply)
}
CMsgSteamSockets_UDP_ChallengeReply::CMsgSteamSockets_UDP_ChallengeReply(const CMsgSteamSockets_UDP_ChallengeReply& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  CMsgSteamSockets_UDP_ChallengeReply* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){from._impl_._has_bits_}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.challenge_){}
    , decltype(_impl_.connection_id_){}
    , decltype(_impl_.protocol_version_){}
    , decltype(_impl_.your_timestamp_){}};

  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::memcpy(&_impl_.challenge_, &from._impl_.challenge_,
    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.your_timestamp_) -
    reinterpret_cast<char*>(&_impl_.challenge_)) + sizeof(_impl_.your_timestamp_));
  // @@protoc_insertion_point(copy_constructor:CMsgSteamSockets_UDP_ChallengeReply)
}

inline void CMsgSteamSockets_UDP_ChallengeReply::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.challenge_){uint64_t{0u}}
    , decltype(_impl_.connection_id_){0u}
    , decltype(_impl_.protocol_version_){0u}
    , decltype(_impl_.your_timestamp_){uint64_t{0u}}
  };
}

CMsgSteamSockets_UDP_ChallengeReply::~CMsgSteamSockets_UDP_ChallengeReply() {
  // @@protoc_insertion_point(destructor:CMsgSteamSockets_UDP_ChallengeReply)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void CMsgSteamSockets_UDP_ChallengeReply::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
}

void CMsgSteamSockets_UDP_ChallengeReply::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void CMsgSteamSockets_UDP_ChallengeReply::Clear() {
// @@protoc_insertion_point(message_clear_start:CMsgSteamSockets_UDP_ChallengeReply)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x0000000fu) {
    ::memset(&_impl_.challenge_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&_impl_.your_timestamp_) -
        reinterpret_cast<char*>(&_impl_.challenge_)) + sizeof(_impl_.your_timestamp_));
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* CMsgSteamSockets_UDP_ChallengeReply::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional fixed32 connection_id = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 13)) {
          _Internal::set_has_connection_id(&has_bits);
          _impl_.connection_id_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<uint32_t>(ptr);
          ptr += sizeof(uint32_t);
        } else
          goto handle_unusual;
        continue;
      // optional fixed64 challenge = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 17)) {
          _Internal::set_has_challenge(&has_bits);
          _impl_.challenge_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<uint64_t>(ptr);
          ptr += sizeof(uint64_t);
        } else
          goto handle_unusual;
        continue;
      // optional fixed64 your_timestamp = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 25)) {
          _Internal::set_has_your_timestamp(&has_bits);
          _impl_.your_timestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<uint64_t>(ptr);
          ptr += sizeof(uint64_t);
        } else
          goto handle_unusual;
        continue;
      // optional uint32 protocol_version = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
          _Internal::set_has_protocol_version(&has_bits);
          _impl_.protocol_version_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _impl_._has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* CMsgSteamSockets_UDP_ChallengeReply::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:CMsgSteamSockets_UDP_ChallengeReply)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  // optional fixed32 connection_id = 1;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteFixed32ToArray(1, this->_internal_connection_id(), target);
  }

  // optional fixed64 challenge = 2;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteFixed64ToArray(2, this->_internal_challenge(), target);
  }

  // optional fixed64 your_timestamp = 3;
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteFixed64ToArray(3, this->_internal_your_timestamp(), target);
  }

  // optional uint32 protocol_version = 4;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(4, this->_internal_protocol_version(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:CMsgSteamSockets_UDP_ChallengeReply)
  return target;
}

size_t CMsgSteamSockets_UDP_ChallengeReply::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:CMsgSteamSockets_UDP_ChallengeReply)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x0000000fu) {
    // optional fixed64 challenge = 2;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 + 8;
    }

    // optional fixed32 connection_id = 1;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 + 4;
    }

    // optional uint32 protocol_version = 4;
    if (cached_has_bits & 0x00000004u) {
      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_protocol_version());
    }

    // optional fixed64 your_timestamp = 3;
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 + 8;
    }

  }
  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData CMsgSteamSockets_UDP_ChallengeReply::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
    CMsgSteamSockets_UDP_ChallengeReply::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*CMsgSteamSockets_UDP_ChallengeReply::GetClassData() const { return &_class_data_; }


void CMsgSteamSockets_UDP_ChallengeReply::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
  auto* const _this = static_cast<CMsgSteamSockets_UDP_ChallengeReply*>(&to_msg);
  auto& from = static_cast<const CMsgSteamSockets_UDP_ChallengeReply&>(from_msg);
  // @@protoc_insertion_point(class_specific_merge_from_start:CMsgSteamSockets_UDP_ChallengeReply)
  GOOGLE_DCHECK_NE(&from, _this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._impl_._has_bits_[0];
  if (cached_has_bits & 0x0000000fu) {
    if (cached_has_bits & 0x00000001u) {
      _this->_impl_.challenge_ = from._impl_.challenge_;
    }
    if (cached_has_bits & 0x00000002u) {
      _this->_impl_.connection_id_ = from._impl_.connection_id_;
    }
    if (cached_has_bits & 0x00000004u) {
      _this->_impl_.protocol_version_ = from._impl_.protocol_version_;
    }
    if (cached_has_bits & 0x00000008u) {
      _this->_impl_.your_timestamp_ = from._impl_.your_timestamp_;
    }
    _this->_impl_._has_bits_[0] |= cached_has_bits;
  }
  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

bool CMsgSteamSockets_UDP_ChallengeReply::IsInitialized() const {
  return true;
}

void CMsgSteamSockets_UDP_ChallengeReply::InternalSwap(CMsgSteamSockets_UDP_ChallengeReply* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(CMsgSteamSockets_UDP_ChallengeReply, _impl_.your_timestamp_)
      + sizeof(CMsgSteamSockets_UDP_ChallengeReply::_impl_.your_timestamp_)
      - PROTOBUF_FIELD_OFFSET(CMsgSteamSockets_UDP_ChallengeReply, _impl_.challenge_)>(
          reinterpret_cast<char*>(&_impl_.challenge_),
          reinterpret_cast<char*>(&other->_impl_.challenge_));
}

::PROTOBUF_NAMESPACE_ID::Metadata CMsgSteamSockets_UDP_ChallengeReply::GetMetadata() const {
  return ::_pbi::AssignDescriptors(
      &descriptor_table_steamnetworkingsockets_5fmessages_5fudp_2eproto_getter, &descriptor_table_steamnetworkingsockets_5fmessages_5fudp_2eproto_once,
      file_level_metadata_steamnetworkingsockets_5fmessages_5fudp_2eproto[1]);
}

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

class CMsgSteamSockets_UDP_ConnectRequest::_Internal {
 public:
  using HasBits = decltype(std::declval<CMsgSteamSockets_UDP_ConnectRequest>()._impl_._has_bits_);
  static void set_has_client_connection_id(HasBits* has_bits) {
    (*has_bits)[0] |= 64u;
  }
  static void set_has_challenge(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
  static void set_has_my_timestamp(HasBits* has_bits) {
    (*has_bits)[0] |= 256u;
  }
  static void set_has_ping_est_ms(HasBits* has_bits) {
    (*has_bits)[0] |= 128u;
  }
  static const ::CMsgSteamDatagramSessionCryptInfoSigned& crypt(const CMsgSteamSockets_UDP_ConnectRequest* msg);
  static void set_has_crypt(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static const ::CMsgSteamDatagramCertificateSigned& cert(const CMsgSteamSockets_UDP_ConnectRequest* msg);
  static void set_has_cert(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_legacy_protocol_version(HasBits* has_bits) {
    (*has_bits)[0] |= 512u;
  }
  static void set_has_identity_string(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_legacy_client_steam_id(HasBits* has_bits) {
    (*has_bits)[0] |= 32u;
  }
  static const ::CMsgSteamNetworkingIdentityLegacyBinary& legacy_identity_binary(const CMsgSteamSockets_UDP_ConnectRequest* msg);
  static void set_has_legacy_identity_binary(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
};

const ::CMsgSteamDatagramSessionCryptInfoSigned&
CMsgSteamSockets_UDP_ConnectRequest::_Internal::crypt(const CMsgSteamSockets_UDP_ConnectRequest* msg) {
  return *msg->_impl_.crypt_;
}
const ::CMsgSteamDatagramCertificateSigned&
CMsgSteamSockets_UDP_ConnectRequest::_Internal::cert(const CMsgSteamSockets_UDP_ConnectRequest* msg) {
  return *msg->_impl_.cert_;
}
const ::CMsgSteamNetworkingIdentityLegacyBinary&
CMsgSteamSockets_UDP_ConnectRequest::_Internal::legacy_identity_binary(const CMsgSteamSockets_UDP_ConnectRequest* msg) {
  return *msg->_impl_.legacy_identity_binary_;
}
void CMsgSteamSockets_UDP_ConnectRequest::clear_crypt() {
  if (_impl_.crypt_ != nullptr) _impl_.crypt_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
void CMsgSteamSockets_UDP_ConnectRequest::clear_cert() {
  if (_impl_.cert_ != nullptr) _impl_.cert_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
void CMsgSteamSockets_UDP_ConnectRequest::clear_legacy_identity_binary() {
  if (_impl_.legacy_identity_binary_ != nullptr) _impl_.legacy_identity_binary_->Clear();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
CMsgSteamSockets_UDP_ConnectRequest::CMsgSteamSockets_UDP_ConnectRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:CMsgSteamSockets_UDP_ConnectRequest)
}
CMsgSteamSockets_UDP_ConnectRequest::CMsgSteamSockets_UDP_ConnectRequest(const CMsgSteamSockets_UDP_ConnectRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  CMsgSteamSockets_UDP_ConnectRequest* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){from._impl_._has_bits_}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.identity_string_){}
    , decltype(_impl_.cert_){nullptr}
    , decltype(_impl_.crypt_){nullptr}
    , decltype(_impl_.legacy_identity_binary_){nullptr}
    , decltype(_impl_.challenge_){}
    , decltype(_impl_.legacy_client_steam_id_){}
    , decltype(_impl_.client_connection_id_){}
    , decltype(_impl_.ping_est_ms_){}
    , decltype(_impl_.my_timestamp_){}
    , decltype(_impl_.legacy_protocol_version_){}};

  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  _impl_.identity_string_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.identity_string_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (from._internal_has_identity_string()) {
    _this->_impl_.identity_string_.Set(from._internal_identity_string(), 
      _this->GetArenaForAllocation());
  }
  if (from._internal_has_cert()) {
    _this->_impl_.cert_ = new ::CMsgSteamDatagramCertificateSigned(*from._impl_.cert_);
  }
  if (from._internal_has_crypt()) {
    _this->_impl_.crypt_ = new ::CMsgSteamDatagramSessionCryptInfoSigned(*from._impl_.crypt_);
  }
  if (from._internal_has_legacy_identity_binary()) {
    _this->_impl_.legacy_identity_binary_ = new ::CMsgSteamNetworkingIdentityLegacyBinary(*from._impl_.legacy_identity_binary_);
  }
  ::memcpy(&_impl_.challenge_, &from._impl_.challenge_,
    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.legacy_protocol_version_) -
    reinterpret_cast<char*>(&_impl_.challenge_)) + sizeof(_impl_.legacy_protocol_version_));
  // @@protoc_insertion_point(copy_constructor:CMsgSteamSockets_UDP_ConnectRequest)
}

inline void CMsgSteamSockets_UDP_ConnectRequest::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.identity_string_){}
    , decltype(_impl_.cert_){nullptr}
    , decltype(_impl_.crypt_){nullptr}
    , decltype(_impl_.legacy_identity_binary_){nullptr}
    , decltype(_impl_.challenge_){uint64_t{0u}}
    , decltype(_impl_.legacy_client_steam_id_){uint64_t{0u}}
    , decltype(_impl_.client_connection_id_){0u}
    , decltype(_impl_.ping_est_ms_){0u}
    , decltype(_impl_.my_timestamp_){uint64_t{0u}}
    , decltype(_impl_.legacy_protocol_version_){0u}
  };
  _impl_.identity_string_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.identity_string_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
}

CMsgSteamSockets_UDP_ConnectRequest::~CMsgSteamSockets_UDP_ConnectRequest() {
  // @@protoc_insertion_point(destructor:CMsgSteamSockets_UDP_ConnectRequest)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void CMsgSteamSockets_UDP_ConnectRequest::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.identity_string_.Destroy();
  if (this != internal_default_instance()) delete _impl_.cert_;
  if (this != internal_default_instance()) delete _impl_.crypt_;
  if (this != internal_default_instance()) delete _impl_.legacy_identity_binary_;
}

void CMsgSteamSockets_UDP_ConnectRequest::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void CMsgSteamSockets_UDP_ConnectRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:CMsgSteamSockets_UDP_ConnectRequest)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x0000000fu) {
    if (cached_has_bits & 0x00000001u) {
      _impl_.identity_string_.ClearNonDefaultToEmpty();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(_impl_.cert_ != nullptr);
      _impl_.cert_->Clear();
    }
    if (cached_has_bits & 0x00000004u) {
      GOOGLE_DCHECK(_impl_.crypt_ != nullptr);
      _impl_.crypt_->Clear();
    }
    if (cached_has_bits & 0x00000008u) {
      GOOGLE_DCHECK(_impl_.legacy_identity_binary_ != nullptr);
      _impl_.legacy_identity_binary_->Clear();
    }
  }
  if (cached_has_bits & 0x000000f0u) {
    ::memset(&_impl_.challenge_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&_impl_.ping_est_ms_) -
        reinterpret_cast<char*>(&_impl_.challenge_)) + sizeof(_impl_.ping_est_ms_));
  }
  if (cached_has_bits & 0x00000300u) {
    ::memset(&_impl_.my_timestamp_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&_impl_.legacy_protocol_version_) -
        reinterpret_cast<char*>(&_impl_.my_timestamp_)) + sizeof(_impl_.legacy_protocol_version_));
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* CMsgSteamSockets_UDP_ConnectRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional fixed32 client_connection_id = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 13)) {
          _Internal::set_has_client_connection_id(&has_bits);
          _impl_.client_connection_id_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<uint32_t>(ptr);
          ptr += sizeof(uint32_t);
        } else
          goto handle_unusual;
        continue;
      // optional fixed64 challenge = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 17)) {
          _Internal::set_has_challenge(&has_bits);
          _impl_.challenge_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<uint64_t>(ptr);
          ptr += sizeof(uint64_t);
        } else
          goto handle_unusual;
        continue;
      // optional fixed64 legacy_client_steam_id = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 25)) {
          _Internal::set_has_legacy_client_steam_id(&has_bits);
          _impl_.legacy_client_steam_id_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<uint64_t>(ptr);
          ptr += sizeof(uint64_t);
        } else
          goto handle_unusual;
        continue;
      // optional .CMsgSteamDatagramCertificateSigned cert = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
          ptr = ctx->ParseMessage(_internal_mutable_cert(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional fixed64 my_timestamp = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 41)) {
          _Internal::set_has_my_timestamp(&has_bits);
          _impl_.my_timestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<uint64_t>(ptr);
          ptr += sizeof(uint64_t);
        } else
          goto handle_unusual;
        continue;
      // optional uint32 ping_est_ms = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 48)) {
          _Internal::set_has_ping_est_ms(&has_bits);
          _impl_.ping_est_ms_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional .CMsgSteamDatagramSessionCryptInfoSigned crypt = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 58)) {
          ptr = ctx->ParseMessage(_internal_mutable_crypt(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional uint32 legacy_protocol_version = 8;
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 64)) {
          _Internal::set_has_legacy_protocol_version(&has_bits);
          _impl_.legacy_protocol_version_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional .CMsgSteamNetworkingIdentityLegacyBinary legacy_identity_binary = 9;
      case 9:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 74)) {
          ptr = ctx->ParseMessage(_internal_mutable_legacy_identity_binary(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional string identity_string = 10;
      case 10:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 82)) {
          auto str = _internal_mutable_identity_string();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          #ifndef NDEBUG
          ::_pbi::VerifyUTF8(str, "CMsgSteamSockets_UDP_ConnectRequest.identity_string");
          #endif  // !NDEBUG
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _impl_._has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* CMsgSteamSockets_UDP_ConnectRequest::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:CMsgSteamSockets_UDP_ConnectRequest)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  // optional fixed32 client_connection_id = 1;
  if (cached_has_bits & 0x00000040u) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteFixed32ToArray(1, this->_internal_client_connection_id(), target);
  }

  // optional fixed64 challenge = 2;
  if (cached_has_bits & 0x00000010u) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteFixed64ToArray(2, this->_internal_challenge(), target);
  }

  // optional fixed64 legacy_client_steam_id = 3;
  if (cached_has_bits & 0x00000020u) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteFixed64ToArray(3, this->_internal_legacy_client_steam_id(), target);
  }

  // optional .CMsgSteamDatagramCertificateSigned cert = 4;
  if (cached_has_bits & 0x00000002u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(4, _Internal::cert(this),
        _Internal::cert(this).GetCachedSize(), target, stream);
  }

  // optional fixed64 my_timestamp = 5;
  if (cached_has_bits & 0x00000100u) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteFixed64ToArray(5, this->_internal_my_timestamp(), target);
  }

  // optional uint32 ping_est_ms = 6;
  if (cached_has_bits & 0x00000080u) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(6, this->_internal_ping_est_ms(), target);
  }

  // optional .CMsgSteamDatagramSessionCryptInfoSigned crypt = 7;
  if (cached_has_bits & 0x00000004u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(7, _Internal::crypt(this),
        _Internal::crypt(this).GetCachedSize(), target, stream);
  }

  // optional uint32 legacy_protocol_version = 8;
  if (cached_has_bits & 0x00000200u) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(8, this->_internal_legacy_protocol_version(), target);
  }

  // optional .CMsgSteamNetworkingIdentityLegacyBinary legacy_identity_binary = 9;
  if (cached_has_bits & 0x00000008u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(9, _Internal::legacy_identity_binary(this),
        _Internal::legacy_identity_binary(this).GetCachedSize(), target, stream);
  }

  // optional string identity_string = 10;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_identity_string().data(), static_cast<int>(this->_internal_identity_string().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "CMsgSteamSockets_UDP_ConnectRequest.identity_string");
    target = stream->WriteStringMaybeAliased(
        10, this->_internal_identity_string(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:CMsgSteamSockets_UDP_ConnectRequest)
  return target;
}

size_t CMsgSteamSockets_UDP_ConnectRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:CMsgSteamSockets_UDP_ConnectRequest)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x000000ffu) {
    // optional string identity_string = 10;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_identity_string());
    }

    // optional .CMsgSteamDatagramCertificateSigned cert = 4;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.cert_);
    }

    // optional .CMsgSteamDatagramSessionCryptInfoSigned crypt = 7;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.crypt_);
    }

    // optional .CMsgSteamNetworkingIdentityLegacyBinary legacy_identity_binary = 9;
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.legacy_identity_binary_);
    }

    // optional fixed64 challenge = 2;
    if (cached_has_bits & 0x00000010u) {
      total_size += 1 + 8;
    }

    // optional fixed64 legacy_client_steam_id = 3;
    if (cached_has_bits & 0x00000020u) {
      total_size += 1 + 8;
    }

    // optional fixed32 client_connection_id = 1;
    if (cached_has_bits & 0x00000040u) {
      total_size += 1 + 4;
    }

    // optional uint32 ping_est_ms = 6;
    if (cached_has_bits & 0x00000080u) {
      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_ping_est_ms());
    }

  }
  if (cached_has_bits & 0x00000300u) {
    // optional fixed64 my_timestamp = 5;
    if (cached_has_bits & 0x00000100u) {
      total_size += 1 + 8;
    }

    // optional uint32 legacy_protocol_version = 8;
    if (cached_has_bits & 0x00000200u) {
      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_legacy_protocol_version());
    }

  }
  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData CMsgSteamSockets_UDP_ConnectRequest::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
    CMsgSteamSockets_UDP_ConnectRequest::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*CMsgSteamSockets_UDP_ConnectRequest::GetClassData() const { return &_class_data_; }


void CMsgSteamSockets_UDP_ConnectRequest::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
  auto* const _this = static_cast<CMsgSteamSockets_UDP_ConnectRequest*>(&to_msg);
  auto& from = static_cast<const CMsgSteamSockets_UDP_ConnectRequest&>(from_msg);
  // @@protoc_insertion_point(class_specific_merge_from_start:CMsgSteamSockets_UDP_ConnectRequest)
  GOOGLE_DCHECK_NE(&from, _this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._impl_._has_bits_[0];
  if (cached_has_bits & 0x000000ffu) {
    if (cached_has_bits & 0x00000001u) {
      _this->_internal_set_identity_string(from._internal_identity_string());
    }
    if (cached_has_bits & 0x00000002u) {
      _this->_internal_mutable_cert()->::CMsgSteamDatagramCertificateSigned::MergeFrom(
          from._internal_cert());
    }
    if (cached_has_bits & 0x00000004u) {
      _this->_internal_mutable_crypt()->::CMsgSteamDatagramSessionCryptInfoSigned::MergeFrom(
          from._internal_crypt());
    }
    if (cached_has_bits & 0x00000008u) {
      _this->_internal_mutable_legacy_identity_binary()->::CMsgSteamNetworkingIdentityLegacyBinary::MergeFrom(
          from._internal_legacy_identity_binary());
    }
    if (cached_has_bits & 0x00000010u) {
      _this->_impl_.challenge_ = from._impl_.challenge_;
    }
    if (cached_has_bits & 0x00000020u) {
      _this->_impl_.legacy_client_steam_id_ = from._impl_.legacy_client_steam_id_;
    }
    if (cached_has_bits & 0x00000040u) {
      _this->_impl_.client_connection_id_ = from._impl_.client_connection_id_;
    }
    if (cached_has_bits & 0x00000080u) {
      _this->_impl_.ping_est_ms_ = from._impl_.ping_est_ms_;
    }
    _this->_impl_._has_bits_[0] |= cached_has_bits;
  }
  if (cached_has_bits & 0x00000300u) {
    if (cached_has_bits & 0x00000100u) {
      _this->_impl_.my_timestamp_ = from._impl_.my_timestamp_;
    }
    if (cached_has_bits & 0x00000200u) {
      _this->_impl_.legacy_protocol_version_ = from._impl_.legacy_protocol_version_;
    }
    _this->_impl_._has_bits_[0] |= cached_has_bits;
  }
  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

bool CMsgSteamSockets_UDP_ConnectRequest::IsInitialized() const {
  return true;
}

void CMsgSteamSockets_UDP_ConnectRequest::InternalSwap(CMsgSteamSockets_UDP_ConnectRequest* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &_impl_.identity_string_, lhs_arena,
      &other->_impl_.identity_string_, rhs_arena
  );
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(CMsgSteamSockets_UDP_ConnectRequest, _impl_.legacy_protocol_version_)
      + sizeof(CMsgSteamSockets_UDP_ConnectRequest::_impl_.legacy_protocol_version_)
      - PROTOBUF_FIELD_OFFSET(CMsgSteamSockets_UDP_ConnectRequest, _impl_.cert_)>(
          reinterpret_cast<char*>(&_impl_.cert_),
          reinterpret_cast<char*>(&other->_impl_.cert_));
}

::PROTOBUF_NAMESPACE_ID::Metadata CMsgSteamSockets_UDP_ConnectRequest::GetMetadata() const {
  return ::_pbi::AssignDescriptors(
      &descriptor_table_steamnetworkingsockets_5fmessages_5fudp_2eproto_getter, &descriptor_table_steamnetworkingsockets_5fmessages_5fudp_2eproto_once,
      file_level_metadata_steamnetworkingsockets_5fmessages_5fudp_2eproto[2]);
}

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

class CMsgSteamSockets_UDP_ConnectOK::_Internal {
 public:
  using HasBits = decltype(std::declval<CMsgSteamSockets_UDP_ConnectOK>()._impl_._has_bits_);
  static void set_has_client_connection_id(HasBits* has_bits) {
    (*has_bits)[0] |= 32u;
  }
  static void set_has_server_connection_id(HasBits* has_bits) {
    (*has_bits)[0] |= 256u;
  }
  static void set_has_your_timestamp(HasBits* has_bits) {
    (*has_bits)[0] |= 128u;
  }
  static void set_has_delay_time_usec(HasBits* has_bits) {
    (*has_bits)[0] |= 64u;
  }
  static const ::CMsgSteamDatagramSessionCryptInfoSigned& crypt(const CMsgSteamSockets_UDP_ConnectOK* msg);
  static void set_has_crypt(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static const ::CMsgSteamDatagramCertificateSigned& cert(const CMsgSteamSockets_UDP_ConnectOK* msg);
  static void set_has_cert(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_identity_string(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_legacy_server_steam_id(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
  static const ::CMsgSteamNetworkingIdentityLegacyBinary& legacy_identity_binary(const CMsgSteamSockets_UDP_ConnectOK* msg);
  static void set_has_legacy_identity_binary(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
};

const ::CMsgSteamDatagramSessionCryptInfoSigned&
CMsgSteamSockets_UDP_ConnectOK::_Internal::crypt(const CMsgSteamSockets_UDP_ConnectOK* msg) {
  return *msg->_impl_.crypt_;
}
const ::CMsgSteamDatagramCertificateSigned&
CMsgSteamSockets_UDP_ConnectOK::_Internal::cert(const CMsgSteamSockets_UDP_ConnectOK* msg) {
  return *msg->_impl_.cert_;
}
const ::CMsgSteamNetworkingIdentityLegacyBinary&
CMsgSteamSockets_UDP_ConnectOK::_Internal::legacy_identity_binary(const CMsgSteamSockets_UDP_ConnectOK* msg) {
  return *msg->_impl_.legacy_identity_binary_;
}
void CMsgSteamSockets_UDP_ConnectOK::clear_crypt() {
  if (_impl_.crypt_ != nullptr) _impl_.crypt_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
void CMsgSteamSockets_UDP_ConnectOK::clear_cert() {
  if (_impl_.cert_ != nullptr) _impl_.cert_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
void CMsgSteamSockets_UDP_ConnectOK::clear_legacy_identity_binary() {
  if (_impl_.legacy_identity_binary_ != nullptr) _impl_.legacy_identity_binary_->Clear();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
CMsgSteamSockets_UDP_ConnectOK::CMsgSteamSockets_UDP_ConnectOK(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:CMsgSteamSockets_UDP_ConnectOK)
}
CMsgSteamSockets_UDP_ConnectOK::CMsgSteamSockets_UDP_ConnectOK(const CMsgSteamSockets_UDP_ConnectOK& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  CMsgSteamSockets_UDP_ConnectOK* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){from._impl_._has_bits_}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.identity_string_){}
    , decltype(_impl_.crypt_){nullptr}
    , decltype(_impl_.cert_){nullptr}
    , decltype(_impl_.legacy_identity_binary_){nullptr}
    , decltype(_impl_.legacy_server_steam_id_){}
    , decltype(_impl_.client_connection_id_){}
    , decltype(_impl_.delay_time_usec_){}
    , decltype(_impl_.your_timestamp_){}
    , decltype(_impl_.server_connection_id_){}};

  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  _impl_.identity_string_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.identity_string_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (from._internal_has_identity_string()) {
    _this->_impl_.identity_string_.Set(from._internal_identity_string(), 
      _this->GetArenaForAllocation());
  }
  if (from._internal_has_crypt()) {
    _this->_impl_.crypt_ = new ::CMsgSteamDatagramSessionCryptInfoSigned(*from._impl_.crypt_);
  }
  if (from._internal_has_cert()) {
    _this->_impl_.cert_ = new ::CMsgSteamDatagramCertificateSigned(*from._impl_.cert_);
  }
  if (from._internal_has_legacy_identity_binary()) {
    _this->_impl_.legacy_identity_binary_ = new ::CMsgSteamNetworkingIdentityLegacyBinary(*from._impl_.legacy_identity_binary_);
  }
  ::memcpy(&_impl_.legacy_server_steam_id_, &from._impl_.legacy_server_steam_id_,
    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.server_connection_id_) -
    reinterpret_cast<char*>(&_impl_.legacy_server_steam_id_)) + sizeof(_impl_.server_connection_id_));
  // @@protoc_insertion_point(copy_constructor:CMsgSteamSockets_UDP_ConnectOK)
}

inline void CMsgSteamSockets_UDP_ConnectOK::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.identity_string_){}
    , decltype(_impl_.crypt_){nullptr}
    , decltype(_impl_.cert_){nullptr}
    , decltype(_impl_.legacy_identity_binary_){nullptr}
    , decltype(_impl_.legacy_server_steam_id_){uint64_t{0u}}
    , decltype(_impl_.client_connection_id_){0u}
    , decltype(_impl_.delay_time_usec_){0u}
    , decltype(_impl_.your_timestamp_){uint64_t{0u}}
    , decltype(_impl_.server_connection_id_){0u}
  };
  _impl_.identity_string_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.identity_string_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
}

CMsgSteamSockets_UDP_ConnectOK::~CMsgSteamSockets_UDP_ConnectOK() {
  // @@protoc_insertion_point(destructor:CMsgSteamSockets_UDP_ConnectOK)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void CMsgSteamSockets_UDP_ConnectOK::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.identity_string_.Destroy();
  if (this != internal_default_instance()) delete _impl_.crypt_;
  if (this != internal_default_instance()) delete _impl_.cert_;
  if (this != internal_default_instance()) delete _impl_.legacy_identity_binary_;
}

void CMsgSteamSockets_UDP_ConnectOK::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void CMsgSteamSockets_UDP_ConnectOK::Clear() {
// @@protoc_insertion_point(message_clear_start:CMsgSteamSockets_UDP_ConnectOK)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x0000000fu) {
    if (cached_has_bits & 0x00000001u) {
      _impl_.identity_string_.ClearNonDefaultToEmpty();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(_impl_.crypt_ != nullptr);
      _impl_.crypt_->Clear();
    }
    if (cached_has_bits & 0x00000004u) {
      GOOGLE_DCHECK(_impl_.cert_ != nullptr);
      _impl_.cert_->Clear();
    }
    if (cached_has_bits & 0x00000008u) {
      GOOGLE_DCHECK(_impl_.legacy_identity_binary_ != nullptr);
      _impl_.legacy_identity_binary_->Clear();
    }
  }
  if (cached_has_bits & 0x000000f0u) {
    ::memset(&_impl_.legacy_server_steam_id_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&_impl_.your_timestamp_) -
        reinterpret_cast<char*>(&_impl_.legacy_server_steam_id_)) + sizeof(_impl_.your_timestamp_));
  }
  _impl_.server_connection_id_ = 0u;
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* CMsgSteamSockets_UDP_ConnectOK::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional fixed32 client_connection_id = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 13)) {
          _Internal::set_has_client_connection_id(&has_bits);
          _impl_.client_connection_id_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<uint32_t>(ptr);
          ptr += sizeof(uint32_t);
        } else
          goto handle_unusual;
        continue;
      // optional fixed64 legacy_server_steam_id = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 17)) {
          _Internal::set_has_legacy_server_steam_id(&has_bits);
          _impl_.legacy_server_steam_id_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<uint64_t>(ptr);
          ptr += sizeof(uint64_t);
        } else
          goto handle_unusual;
        continue;
      // optional fixed64 your_timestamp = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 25)) {
          _Internal::set_has_your_timestamp(&has_bits);
          _impl_.your_timestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<uint64_t>(ptr);
          ptr += sizeof(uint64_t);
        } else
          goto handle_unusual;
        continue;
      // optional uint32 delay_time_usec = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
          _Internal::set_has_delay_time_usec(&has_bits);
          _impl_.delay_time_usec_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional fixed32 server_connection_id = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 45)) {
          _Internal::set_has_server_connection_id(&has_bits);
          _impl_.server_connection_id_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<uint32_t>(ptr);
          ptr += sizeof(uint32_t);
        } else
          goto handle_unusual;
        continue;
      // optional .CMsgSteamDatagramSessionCryptInfoSigned crypt = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 58)) {
          ptr = ctx->ParseMessage(_internal_mutable_crypt(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional .CMsgSteamDatagramCertificateSigned cert = 8;
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 66)) {
          ptr = ctx->ParseMessage(_internal_mutable_cert(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional .CMsgSteamNetworkingIdentityLegacyBinary legacy_identity_binary = 10;
      case 10:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 82)) {
          ptr = ctx->ParseMessage(_internal_mutable_legacy_identity_binary(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional string identity_string = 11;
      case 11:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 90)) {
          auto str = _internal_mutable_identity_string();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          #ifndef NDEBUG
          ::_pbi::VerifyUTF8(str, "CMsgSteamSockets_UDP_ConnectOK.identity_string");
          #endif  // !NDEBUG
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _impl_._has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* CMsgSteamSockets_UDP_ConnectOK::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:CMsgSteamSockets_UDP_ConnectOK)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  // optional fixed32 client_connection_id = 1;
  if (cached_has_bits & 0x00000020u) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteFixed32ToArray(1, this->_internal_client_connection_id(), target);
  }

  // optional fixed64 legacy_server_steam_id = 2;
  if (cached_has_bits & 0x00000010u) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteFixed64ToArray(2, this->_internal_legacy_server_steam_id(), target);
  }

  // optional fixed64 your_timestamp = 3;
  if (cached_has_bits & 0x00000080u) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteFixed64ToArray(3, this->_internal_your_timestamp(), target);
  }

  // optional uint32 delay_time_usec = 4;
  if (cached_has_bits & 0x00000040u) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(4, this->_internal_delay_time_usec(), target);
  }

  // optional fixed32 server_connection_id = 5;
  if (cached_has_bits & 0x00000100u) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteFixed32ToArray(5, this->_internal_server_connection_id(), target);
  }

  // optional .CMsgSteamDatagramSessionCryptInfoSigned crypt = 7;
  if (cached_has_bits & 0x00000002u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(7, _Internal::crypt(this),
        _Internal::crypt(this).GetCachedSize(), target, stream);
  }

  // optional .CMsgSteamDatagramCertificateSigned cert = 8;
  if (cached_has_bits & 0x00000004u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(8, _Internal::cert(this),
        _Internal::cert(this).GetCachedSize(), target, stream);
  }

  // optional .CMsgSteamNetworkingIdentityLegacyBinary legacy_identity_binary = 10;
  if (cached_has_bits & 0x00000008u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(10, _Internal::legacy_identity_binary(this),
        _Internal::legacy_identity_binary(this).GetCachedSize(), target, stream);
  }

  // optional string identity_string = 11;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_identity_string().data(), static_cast<int>(this->_internal_identity_string().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "CMsgSteamSockets_UDP_ConnectOK.identity_string");
    target = stream->WriteStringMaybeAliased(
        11, this->_internal_identity_string(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:CMsgSteamSockets_UDP_ConnectOK)
  return target;
}

size_t CMsgSteamSockets_UDP_ConnectOK::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:CMsgSteamSockets_UDP_ConnectOK)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x000000ffu) {
    // optional string identity_string = 11;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_identity_string());
    }

    // optional .CMsgSteamDatagramSessionCryptInfoSigned crypt = 7;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.crypt_);
    }

    // optional .CMsgSteamDatagramCertificateSigned cert = 8;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.cert_);
    }

    // optional .CMsgSteamNetworkingIdentityLegacyBinary legacy_identity_binary = 10;
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.legacy_identity_binary_);
    }

    // optional fixed64 legacy_server_steam_id = 2;
    if (cached_has_bits & 0x00000010u) {
      total_size += 1 + 8;
    }

    // optional fixed32 client_connection_id = 1;
    if (cached_has_bits & 0x00000020u) {
      total_size += 1 + 4;
    }

    // optional uint32 delay_time_usec = 4;
    if (cached_has_bits & 0x00000040u) {
      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_delay_time_usec());
    }

    // optional fixed64 your_timestamp = 3;
    if (cached_has_bits & 0x00000080u) {
      total_size += 1 + 8;
    }

  }
  // optional fixed32 server_connection_id = 5;
  if (cached_has_bits & 0x00000100u) {
    total_size += 1 + 4;
  }

  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData CMsgSteamSockets_UDP_ConnectOK::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
    CMsgSteamSockets_UDP_ConnectOK::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*CMsgSteamSockets_UDP_ConnectOK::GetClassData() const { return &_class_data_; }


void CMsgSteamSockets_UDP_ConnectOK::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
  auto* const _this = static_cast<CMsgSteamSockets_UDP_ConnectOK*>(&to_msg);
  auto& from = static_cast<const CMsgSteamSockets_UDP_ConnectOK&>(from_msg);
  // @@protoc_insertion_point(class_specific_merge_from_start:CMsgSteamSockets_UDP_ConnectOK)
  GOOGLE_DCHECK_NE(&from, _this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._impl_._has_bits_[0];
  if (cached_has_bits & 0x000000ffu) {
    if (cached_has_bits & 0x00000001u) {
      _this->_internal_set_identity_string(from._internal_identity_string());
    }
    if (cached_has_bits & 0x00000002u) {
      _this->_internal_mutable_crypt()->::CMsgSteamDatagramSessionCryptInfoSigned::MergeFrom(
          from._internal_crypt());
    }
    if (cached_has_bits & 0x00000004u) {
      _this->_internal_mutable_cert()->::CMsgSteamDatagramCertificateSigned::MergeFrom(
          from._internal_cert());
    }
    if (cached_has_bits & 0x00000008u) {
      _this->_internal_mutable_legacy_identity_binary()->::CMsgSteamNetworkingIdentityLegacyBinary::MergeFrom(
          from._internal_legacy_identity_binary());
    }
    if (cached_has_bits & 0x00000010u) {
      _this->_impl_.legacy_server_steam_id_ = from._impl_.legacy_server_steam_id_;
    }
    if (cached_has_bits & 0x00000020u) {
      _this->_impl_.client_connection_id_ = from._impl_.client_connection_id_;
    }
    if (cached_has_bits & 0x00000040u) {
      _this->_impl_.delay_time_usec_ = from._impl_.delay_time_usec_;
    }
    if (cached_has_bits & 0x00000080u) {
      _this->_impl_.your_timestamp_ = from._impl_.your_timestamp_;
    }
    _this->_impl_._has_bits_[0] |= cached_has_bits;
  }
  if (cached_has_bits & 0x00000100u) {
    _this->_internal_set_server_connection_id(from._internal_server_connection_id());
  }
  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

bool CMsgSteamSockets_UDP_ConnectOK::IsInitialized() const {
  return true;
}

void CMsgSteamSockets_UDP_ConnectOK::InternalSwap(CMsgSteamSockets_UDP_ConnectOK* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &_impl_.identity_string_, lhs_arena,
      &other->_impl_.identity_string_, rhs_arena
  );
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(CMsgSteamSockets_UDP_ConnectOK, _impl_.server_connection_id_)
      + sizeof(CMsgSteamSockets_UDP_ConnectOK::_impl_.server_connection_id_)
      - PROTOBUF_FIELD_OFFSET(CMsgSteamSockets_UDP_ConnectOK, _impl_.crypt_)>(
          reinterpret_cast<char*>(&_impl_.crypt_),
          reinterpret_cast<char*>(&other->_impl_.crypt_));
}

::PROTOBUF_NAMESPACE_ID::Metadata CMsgSteamSockets_UDP_ConnectOK::GetMetadata() const {
  return ::_pbi::AssignDescriptors(
      &descriptor_table_steamnetworkingsockets_5fmessages_5fudp_2eproto_getter, &descriptor_table_steamnetworkingsockets_5fmessages_5fudp_2eproto_once,
      file_level_metadata_steamnetworkingsockets_5fmessages_5fudp_2eproto[3]);
}

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

class CMsgSteamSockets_UDP_ConnectionClosed::_Internal {
 public:
  using HasBits = decltype(std::declval<CMsgSteamSockets_UDP_ConnectionClosed>()._impl_._has_bits_);
  static void set_has_to_connection_id(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_from_connection_id(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static void set_has_debug(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_reason_code(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
};

CMsgSteamSockets_UDP_ConnectionClosed::CMsgSteamSockets_UDP_ConnectionClosed(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:CMsgSteamSockets_UDP_ConnectionClosed)
}
CMsgSteamSockets_UDP_ConnectionClosed::CMsgSteamSockets_UDP_ConnectionClosed(const CMsgSteamSockets_UDP_ConnectionClosed& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  CMsgSteamSockets_UDP_ConnectionClosed* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){from._impl_._has_bits_}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.debug_){}
    , decltype(_impl_.reason_code_){}
    , decltype(_impl_.to_connection_id_){}
    , decltype(_impl_.from_connection_id_){}};

  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  _impl_.debug_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.debug_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (from._internal_has_debug()) {
    _this->_impl_.debug_.Set(from._internal_debug(), 
      _this->GetArenaForAllocation());
  }
  ::memcpy(&_impl_.reason_code_, &from._impl_.reason_code_,
    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.from_connection_id_) -
    reinterpret_cast<char*>(&_impl_.reason_code_)) + sizeof(_impl_.from_connection_id_));
  // @@protoc_insertion_point(copy_constructor:CMsgSteamSockets_UDP_ConnectionClosed)
}

inline void CMsgSteamSockets_UDP_ConnectionClosed::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.debug_){}
    , decltype(_impl_.reason_code_){0u}
    , decltype(_impl_.to_connection_id_){0u}
    , decltype(_impl_.from_connection_id_){0u}
  };
  _impl_.debug_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    _impl_.debug_.Set("", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
}

CMsgSteamSockets_UDP_ConnectionClosed::~CMsgSteamSockets_UDP_ConnectionClosed() {
  // @@protoc_insertion_point(destructor:CMsgSteamSockets_UDP_ConnectionClosed)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void CMsgSteamSockets_UDP_ConnectionClosed::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.debug_.Destroy();
}

void CMsgSteamSockets_UDP_ConnectionClosed::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void CMsgSteamSockets_UDP_ConnectionClosed::Clear() {
// @@protoc_insertion_point(message_clear_start:CMsgSteamSockets_UDP_ConnectionClosed)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    _impl_.debug_.ClearNonDefaultToEmpty();
  }
  if (cached_has_bits & 0x0000000eu) {
    ::memset(&_impl_.reason_code_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&_impl_.from_connection_id_) -
        reinterpret_cast<char*>(&_impl_.reason_code_)) + sizeof(_impl_.from_connection_id_));
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* CMsgSteamSockets_UDP_ConnectionClosed::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional string debug = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
          auto str = _internal_mutable_debug();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          #ifndef NDEBUG
          ::_pbi::VerifyUTF8(str, "CMsgSteamSockets_UDP_ConnectionClosed.debug");
          #endif  // !NDEBUG
        } else
          goto handle_unusual;
        continue;
      // optional uint32 reason_code = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
          _Internal::set_has_reason_code(&has_bits);
          _impl_.reason_code_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional fixed32 to_connection_id = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 37)) {
          _Internal::set_has_to_connection_id(&has_bits);
          _impl_.to_connection_id_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<uint32_t>(ptr);
          ptr += sizeof(uint32_t);
        } else
          goto handle_unusual;
        continue;
      // optional fixed32 from_connection_id = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 45)) {
          _Internal::set_has_from_connection_id(&has_bits);
          _impl_.from_connection_id_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<uint32_t>(ptr);
          ptr += sizeof(uint32_t);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _impl_._has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* CMsgSteamSockets_UDP_ConnectionClosed::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:CMsgSteamSockets_UDP_ConnectionClosed)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  // optional string debug = 2;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_debug().data(), static_cast<int>(this->_internal_debug().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "CMsgSteamSockets_UDP_ConnectionClosed.debug");
    target = stream->WriteStringMaybeAliased(
        2, this->_internal_debug(), target);
  }

  // optional uint32 reason_code = 3;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_reason_code(), target);
  }

  // optional fixed32 to_connection_id = 4;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteFixed32ToArray(4, this->_internal_to_connection_id(), target);
  }

  // optional fixed32 from_connection_id = 5;
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteFixed32ToArray(5, this->_internal_from_connection_id(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:CMsgSteamSockets_UDP_ConnectionClosed)
  return target;
}

size_t CMsgSteamSockets_UDP_ConnectionClosed::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:CMsgSteamSockets_UDP_ConnectionClosed)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x0000000fu) {
    // optional string debug = 2;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_debug());
    }

    // optional uint32 reason_code = 3;
    if (cached_has_bits & 0x00000002u) {
      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_reason_code());
    }

    // optional fixed32 to_connection_id = 4;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 + 4;
    }

    // optional fixed32 from_connection_id = 5;
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 + 4;
    }

  }
  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData CMsgSteamSockets_UDP_ConnectionClosed::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
    CMsgSteamSockets_UDP_ConnectionClosed::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*CMsgSteamSockets_UDP_ConnectionClosed::GetClassData() const { return &_class_data_; }


void CMsgSteamSockets_UDP_ConnectionClosed::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
  auto* const _this = static_cast<CMsgSteamSockets_UDP_ConnectionClosed*>(&to_msg);
  auto& from = static_cast<const CMsgSteamSockets_UDP_ConnectionClosed&>(from_msg);
  // @@protoc_insertion_point(class_specific_merge_from_start:CMsgSteamSockets_UDP_ConnectionClosed)
  GOOGLE_DCHECK_NE(&from, _this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._impl_._has_bits_[0];
  if (cached_has_bits & 0x0000000fu) {
    if (cached_has_bits & 0x00000001u) {
      _this->_internal_set_debug(from._internal_debug());
    }
    if (cached_has_bits & 0x00000002u) {
      _this->_impl_.reason_code_ = from._impl_.reason_code_;
    }
    if (cached_has_bits & 0x00000004u) {
      _this->_impl_.to_connection_id_ = from._impl_.to_connection_id_;
    }
    if (cached_has_bits & 0x00000008u) {
      _this->_impl_.from_connection_id_ = from._impl_.from_connection_id_;
    }
    _this->_impl_._has_bits_[0] |= cached_has_bits;
  }
  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

bool CMsgSteamSockets_UDP_ConnectionClosed::IsInitialized() const {
  return true;
}

void CMsgSteamSockets_UDP_ConnectionClosed::InternalSwap(CMsgSteamSockets_UDP_ConnectionClosed* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &_impl_.debug_, lhs_arena,
      &other->_impl_.debug_, rhs_arena
  );
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(CMsgSteamSockets_UDP_ConnectionClosed, _impl_.from_connection_id_)
      + sizeof(CMsgSteamSockets_UDP_ConnectionClosed::_impl_.from_connection_id_)
      - PROTOBUF_FIELD_OFFSET(CMsgSteamSockets_UDP_ConnectionClosed, _impl_.reason_code_)>(
          reinterpret_cast<char*>(&_impl_.reason_code_),
          reinterpret_cast<char*>(&other->_impl_.reason_code_));
}

::PROTOBUF_NAMESPACE_ID::Metadata CMsgSteamSockets_UDP_ConnectionClosed::GetMetadata() const {
  return ::_pbi::AssignDescriptors(
      &descriptor_table_steamnetworkingsockets_5fmessages_5fudp_2eproto_getter, &descriptor_table_steamnetworkingsockets_5fmessages_5fudp_2eproto_once,
      file_level_metadata_steamnetworkingsockets_5fmessages_5fudp_2eproto[4]);
}

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

class CMsgSteamSockets_UDP_NoConnection::_Internal {
 public:
  using HasBits = decltype(std::declval<CMsgSteamSockets_UDP_NoConnection>()._impl_._has_bits_);
  static void set_has_from_connection_id(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_to_connection_id(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
};

CMsgSteamSockets_UDP_NoConnection::CMsgSteamSockets_UDP_NoConnection(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:CMsgSteamSockets_UDP_NoConnection)
}
CMsgSteamSockets_UDP_NoConnection::CMsgSteamSockets_UDP_NoConnection(const CMsgSteamSockets_UDP_NoConnection& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  CMsgSteamSockets_UDP_NoConnection* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){from._impl_._has_bits_}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.from_connection_id_){}
    , decltype(_impl_.to_connection_id_){}};

  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::memcpy(&_impl_.from_connection_id_, &from._impl_.from_connection_id_,
    static_cast<size_t>(reinterpret_cast<char*>(&_impl_.to_connection_id_) -
    reinterpret_cast<char*>(&_impl_.from_connection_id_)) + sizeof(_impl_.to_connection_id_));
  // @@protoc_insertion_point(copy_constructor:CMsgSteamSockets_UDP_NoConnection)
}

inline void CMsgSteamSockets_UDP_NoConnection::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.from_connection_id_){0u}
    , decltype(_impl_.to_connection_id_){0u}
  };
}

CMsgSteamSockets_UDP_NoConnection::~CMsgSteamSockets_UDP_NoConnection() {
  // @@protoc_insertion_point(destructor:CMsgSteamSockets_UDP_NoConnection)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void CMsgSteamSockets_UDP_NoConnection::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
}

void CMsgSteamSockets_UDP_NoConnection::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void CMsgSteamSockets_UDP_NoConnection::Clear() {
// @@protoc_insertion_point(message_clear_start:CMsgSteamSockets_UDP_NoConnection)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    ::memset(&_impl_.from_connection_id_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&_impl_.to_connection_id_) -
        reinterpret_cast<char*>(&_impl_.from_connection_id_)) + sizeof(_impl_.to_connection_id_));
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* CMsgSteamSockets_UDP_NoConnection::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional fixed32 from_connection_id = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 21)) {
          _Internal::set_has_from_connection_id(&has_bits);
          _impl_.from_connection_id_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<uint32_t>(ptr);
          ptr += sizeof(uint32_t);
        } else
          goto handle_unusual;
        continue;
      // optional fixed32 to_connection_id = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 29)) {
          _Internal::set_has_to_connection_id(&has_bits);
          _impl_.to_connection_id_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<uint32_t>(ptr);
          ptr += sizeof(uint32_t);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _impl_._has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* CMsgSteamSockets_UDP_NoConnection::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:CMsgSteamSockets_UDP_NoConnection)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  // optional fixed32 from_connection_id = 2;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteFixed32ToArray(2, this->_internal_from_connection_id(), target);
  }

  // optional fixed32 to_connection_id = 3;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteFixed32ToArray(3, this->_internal_to_connection_id(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:CMsgSteamSockets_UDP_NoConnection)
  return target;
}

size_t CMsgSteamSockets_UDP_NoConnection::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:CMsgSteamSockets_UDP_NoConnection)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    // optional fixed32 from_connection_id = 2;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 + 4;
    }

    // optional fixed32 to_connection_id = 3;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 + 4;
    }

  }
  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData CMsgSteamSockets_UDP_NoConnection::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
    CMsgSteamSockets_UDP_NoConnection::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*CMsgSteamSockets_UDP_NoConnection::GetClassData() const { return &_class_data_; }


void CMsgSteamSockets_UDP_NoConnection::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
  auto* const _this = static_cast<CMsgSteamSockets_UDP_NoConnection*>(&to_msg);
  auto& from = static_cast<const CMsgSteamSockets_UDP_NoConnection&>(from_msg);
  // @@protoc_insertion_point(class_specific_merge_from_start:CMsgSteamSockets_UDP_NoConnection)
  GOOGLE_DCHECK_NE(&from, _this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._impl_._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      _this->_impl_.from_connection_id_ = from._impl_.from_connection_id_;
    }
    if (cached_has_bits & 0x00000002u) {
      _this->_impl_.to_connection_id_ = from._impl_.to_connection_id_;
    }
    _this->_impl_._has_bits_[0] |= cached_has_bits;
  }
  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

bool CMsgSteamSockets_UDP_NoConnection::IsInitialized() const {
  return true;
}

void CMsgSteamSockets_UDP_NoConnection::InternalSwap(CMsgSteamSockets_UDP_NoConnection* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(CMsgSteamSockets_UDP_NoConnection, _impl_.to_connection_id_)
      + sizeof(CMsgSteamSockets_UDP_NoConnection::_impl_.to_connection_id_)
      - PROTOBUF_FIELD_OFFSET(CMsgSteamSockets_UDP_NoConnection, _impl_.from_connection_id_)>(
          reinterpret_cast<char*>(&_impl_.from_connection_id_),
          reinterpret_cast<char*>(&other->_impl_.from_connection_id_));
}

::PROTOBUF_NAMESPACE_ID::Metadata CMsgSteamSockets_UDP_NoConnection::GetMetadata() const {
  return ::_pbi::AssignDescriptors(
      &descriptor_table_steamnetworkingsockets_5fmessages_5fudp_2eproto_getter, &descriptor_table_steamnetworkingsockets_5fmessages_5fudp_2eproto_once,
      file_level_metadata_steamnetworkingsockets_5fmessages_5fudp_2eproto[5]);
}

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

class CMsgSteamSockets_UDP_Stats::_Internal {
 public:
  using HasBits = decltype(std::declval<CMsgSteamSockets_UDP_Stats>()._impl_._has_bits_);
  static const ::CMsgSteamDatagramConnectionQuality& stats(const CMsgSteamSockets_UDP_Stats* msg);
  static void set_has_stats(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_flags(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
};

const ::CMsgSteamDatagramConnectionQuality&
CMsgSteamSockets_UDP_Stats::_Internal::stats(const CMsgSteamSockets_UDP_Stats* msg) {
  return *msg->_impl_.stats_;
}
void CMsgSteamSockets_UDP_Stats::clear_stats() {
  if (_impl_.stats_ != nullptr) _impl_.stats_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
CMsgSteamSockets_UDP_Stats::CMsgSteamSockets_UDP_Stats(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor(arena, is_message_owned);
  // @@protoc_insertion_point(arena_constructor:CMsgSteamSockets_UDP_Stats)
}
CMsgSteamSockets_UDP_Stats::CMsgSteamSockets_UDP_Stats(const CMsgSteamSockets_UDP_Stats& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  CMsgSteamSockets_UDP_Stats* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){from._impl_._has_bits_}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.stats_){nullptr}
    , decltype(_impl_.flags_){}};

  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_stats()) {
    _this->_impl_.stats_ = new ::CMsgSteamDatagramConnectionQuality(*from._impl_.stats_);
  }
  _this->_impl_.flags_ = from._impl_.flags_;
  // @@protoc_insertion_point(copy_constructor:CMsgSteamSockets_UDP_Stats)
}

inline void CMsgSteamSockets_UDP_Stats::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) {
  (void)arena;
  (void)is_message_owned;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.stats_){nullptr}
    , decltype(_impl_.flags_){0u}
  };
}

CMsgSteamSockets_UDP_Stats::~CMsgSteamSockets_UDP_Stats() {
  // @@protoc_insertion_point(destructor:CMsgSteamSockets_UDP_Stats)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void CMsgSteamSockets_UDP_Stats::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete _impl_.stats_;
}

void CMsgSteamSockets_UDP_Stats::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void CMsgSteamSockets_UDP_Stats::Clear() {
// @@protoc_insertion_point(message_clear_start:CMsgSteamSockets_UDP_Stats)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    GOOGLE_DCHECK(_impl_.stats_ != nullptr);
    _impl_.stats_->Clear();
  }
  _impl_.flags_ = 0u;
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* CMsgSteamSockets_UDP_Stats::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional .CMsgSteamDatagramConnectionQuality stats = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_stats(), ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional uint32 flags = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
          _Internal::set_has_flags(&has_bits);
          _impl_.flags_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _impl_._has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

uint8_t* CMsgSteamSockets_UDP_Stats::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:CMsgSteamSockets_UDP_Stats)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  // optional .CMsgSteamDatagramConnectionQuality stats = 1;
  if (cached_has_bits & 0x00000001u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, _Internal::stats(this),
        _Internal::stats(this).GetCachedSize(), target, stream);
  }

  // optional uint32 flags = 3;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_flags(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:CMsgSteamSockets_UDP_Stats)
  return target;
}

size_t CMsgSteamSockets_UDP_Stats::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:CMsgSteamSockets_UDP_Stats)
  size_t total_size = 0;

  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    // optional .CMsgSteamDatagramConnectionQuality stats = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.stats_);
    }

    // optional uint32 flags = 3;
    if (cached_has_bits & 0x00000002u) {
      total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_flags());
    }

  }
  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData CMsgSteamSockets_UDP_Stats::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck,
    CMsgSteamSockets_UDP_Stats::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*CMsgSteamSockets_UDP_Stats::GetClassData() const { return &_class_data_; }


void CMsgSteamSockets_UDP_Stats::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
  auto* const _this = static_cast<CMsgSteamSockets_UDP_Stats*>(&to_msg);
  auto& from = static_cast<const CMsgSteamSockets_UDP_Stats&>(from_msg);
  // @@protoc_insertion_point(class_specific_merge_from_start:CMsgSteamSockets_UDP_Stats)
  GOOGLE_DCHECK_NE(&from, _this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._impl_._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      _this->_internal_mutable_stats()->::CMsgSteamDatagramConnectionQuality::MergeFrom(
          from._internal_stats());
    }
    if (cached_has_bits & 0x00000002u) {
      _this->_impl_.flags_ = from._impl_.flags_;
    }
    _this->_impl_._has_bits_[0] |= cached_has_bits;
  }
  _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

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

bool CMsgSteamSockets_UDP_Stats::IsInitialized() const {
  return true;
}

void CMsgSteamSockets_UDP_Stats::InternalSwap(CMsgSteamSockets_UDP_Stats* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(CMsgSteamSockets_UDP_Stats, _impl_.flags_)
      + sizeof(CMsgSteamSockets_UDP_Stats::_impl_.flags_)
      - PROTOBUF_FIELD_OFFSET(CMsgSteamSockets_UDP_Stats, _impl_.stats_)>(
          reinterpret_cast<char*>(&_impl_.stats_),
          reinterpret_cast<char*>(&other->_impl_.stats_));
}

::PROTOBUF_NAMESPACE_ID::Metadata CMsgSteamSockets_UDP_Stats::GetMetadata() const {
  return ::_pbi::AssignDescriptors(
      &descriptor_table_steamnetworkingsockets_5fmessages_5fudp_2eproto_getter, &descriptor_table_steamnetworkingsockets_5fmessages_5fudp_2eproto_once,
      file_level_metadata_steamnetworkingsockets_5fmessages_5fudp_2eproto[6]);
}

// @@protoc_insertion_point(namespace_scope)
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::CMsgSteamSockets_UDP_ChallengeRequest*
Arena::CreateMaybeMessage< ::CMsgSteamSockets_UDP_ChallengeRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::CMsgSteamSockets_UDP_ChallengeRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::CMsgSteamSockets_UDP_ChallengeReply*
Arena::CreateMaybeMessage< ::CMsgSteamSockets_UDP_ChallengeReply >(Arena* arena) {
  return Arena::CreateMessageInternal< ::CMsgSteamSockets_UDP_ChallengeReply >(arena);
}
template<> PROTOBUF_NOINLINE ::CMsgSteamSockets_UDP_ConnectRequest*
Arena::CreateMaybeMessage< ::CMsgSteamSockets_UDP_ConnectRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::CMsgSteamSockets_UDP_ConnectRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::CMsgSteamSockets_UDP_ConnectOK*
Arena::CreateMaybeMessage< ::CMsgSteamSockets_UDP_ConnectOK >(Arena* arena) {
  return Arena::CreateMessageInternal< ::CMsgSteamSockets_UDP_ConnectOK >(arena);
}
template<> PROTOBUF_NOINLINE ::CMsgSteamSockets_UDP_ConnectionClosed*
Arena::CreateMaybeMessage< ::CMsgSteamSockets_UDP_ConnectionClosed >(Arena* arena) {
  return Arena::CreateMessageInternal< ::CMsgSteamSockets_UDP_ConnectionClosed >(arena);
}
template<> PROTOBUF_NOINLINE ::CMsgSteamSockets_UDP_NoConnection*
Arena::CreateMaybeMessage< ::CMsgSteamSockets_UDP_NoConnection >(Arena* arena) {
  return Arena::CreateMessageInternal< ::CMsgSteamSockets_UDP_NoConnection >(arena);
}
template<> PROTOBUF_NOINLINE ::CMsgSteamSockets_UDP_Stats*
Arena::CreateMaybeMessage< ::CMsgSteamSockets_UDP_Stats >(Arena* arena) {
  return Arena::CreateMessageInternal< ::CMsgSteamSockets_UDP_Stats >(arena);
}
PROTOBUF_NAMESPACE_CLOSE

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